home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 February: Tool Chest / Apple Developer CD Series Tool Chest February 1996 (Apple Computer)(1996).iso / Sample Code / Sample Code Update 01⁄96 / MenuScripter 3.1 / Sources / MSAppleEvents.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-20  |  167.2 KB  |  6,202 lines  |  [TEXT/MPS ]
  1. /*
  2.     MSAppleEvents.c 
  3.     
  4.     Version 3.1
  5.     
  6.     Copyright © 1995 Apple Computer, Inc., all rights reserved.
  7.     
  8.     MenuScripter by Nigel Humphreys and Jon Lansdell
  9.     AppleEvent to script extensions by Greg Sutton
  10.     
  11.     The AppleEvent handling routines for the MenuScripter example program
  12.     
  13.     This file includes :
  14.     
  15.         a) the code for the AppleEvent initialisation 
  16.         b) the routines for all the Edition Manager events
  17.         c) the Apple® Event Object Support
  18.  
  19. */
  20.  
  21. #include <AppleEvents.h>
  22. #include <Menus.h>
  23. #include <PLStringFuncs.h>
  24. #include <Scrap.h>
  25. #include <LowMem.h>
  26. #include <TextEdit.h>
  27. #include <AEObjects.h>
  28. #include <AEPackObject.h>
  29. #include <AERegistry.h>
  30. #include <ASRegistry.h>
  31. #include <TextUtils.h>
  32. #include "MSGlobals.h"
  33. #include "MSUtils.h"
  34. #include "MSAEUtils.h"
  35. #include "MSWindow.h"
  36. #include "MSFile.h"
  37. #include "MSScript.h"
  38. #include "MSAppleEvents.h"
  39.  
  40. /* these should come from the registry */
  41.         
  42. #define         kAEStartedRecording    'rec1'
  43. #define         kAEStoppedRecording         'rec0'
  44. #define         kAEDontExecute                  0x00002000
  45. #define         errCantWriteSubscriber 10000
  46.  
  47. #define         pContents                 'pcnt' // Borrowed from Quill
  48. #define     cSpot             'cspt'
  49.  
  50. /*
  51.     Text Properties
  52. */
  53.         
  54. #define         pStringWidth            'pwid'
  55.         
  56. /*
  57.     Window Properties - See the Registry for Details
  58. */
  59.         
  60. #define     pPosition                'ppos'
  61. #define         pPageSetup                'PSET' /* One of ours - Not in registry */
  62. #define         pShowBorders            'PBOR' /* Another of ours */
  63. #define     pSelection        'sele' /* changed from pUserSelection */
  64.                 
  65. #define         typeTPrint                'TPNT' /* A raw TPrint record - also one of ours */
  66.  
  67.  
  68. #define     kMenuScripterSuite    'MeSc'
  69. #define     kAEApplyFilter            'ApFi'
  70.  
  71. /*
  72.     Menu properties of our own devising
  73. */
  74.  
  75. #define     pActiveItem       'PACT'
  76.  
  77. /*
  78.     Error Codes
  79. */
  80.         
  81. #define         kAEGenericErr    -1799
  82.  
  83. static long   gBigBrother;
  84. static char  *gTypingBuffer;
  85. static short  gCharsInBuffer;
  86. static AEDesc gTypingTargetObject;
  87.  
  88.  
  89. /*-----------------------------------------------------------------------*/
  90. /**----------                         APPLE EVENT HANDLING                     ---------------**/
  91. /*-----------------------------------------------------------------------*/
  92.  
  93. pascal OSErr GetTHPrintFromDescriptor(const AEDesc *sourceDesc, THPrint *result)
  94.   {
  95.       OSErr   myErr;
  96.         OSErr   ignoreErr;
  97.         Size    ptSize;
  98.         AEDesc  resultDesc;
  99.         
  100.         myErr = AECoerceDesc(sourceDesc,typeTPrint,&resultDesc);
  101.         
  102.         *result = nil;
  103.         
  104.         if (myErr==noErr) 
  105.             {
  106.                 *result = (THPrint)NewHandle(sizeof(TPrint));
  107.                 
  108.                 PrOpen();
  109.                 PrintDefault(*result);
  110.                 
  111.                 HLock((Handle)*result);
  112.     
  113.                 GetRawDataFromDescriptor(&resultDesc,
  114.                                                                  (Ptr)**result,
  115.                                                                  sizeof(TPrint),
  116.                                                                  &ptSize);
  117.                                                                  
  118.                 HUnlock((Handle)*result);
  119.                 
  120.                 if ((ptSize<sizeof(TPrint)) || (PrValidate(*result)))
  121.                     {
  122.                         myErr = errAECoercionFail;
  123.                         DisposHandle((Handle)*result);
  124.                         *result = nil;
  125.                     }
  126.                 
  127.                 PrClose();
  128.             }
  129.         
  130.         if (resultDesc.dataHandle) 
  131.             ignoreErr = AEDisposeDesc(&resultDesc);
  132.             
  133.         return(myErr);
  134.     } /*GetTHPrintFromDescriptor*/
  135.  
  136. /*******************************************************************************/
  137. /*
  138.     Object Accessors - Utility Routines
  139. */
  140.  
  141. #pragma segment ObjectAccessors
  142.  
  143. pascal WindowPtr WindowNameToWindowPtr(StringPtr nameStr)
  144. /* 
  145.     Returns the WindowPtr of the window with title nameStr
  146.     or nil if there is no matching window.
  147. */
  148.     { 
  149.         WindowPtr theWindow;
  150.         Str255    windTitle;
  151.             
  152.         theWindow = (WindowPtr)LMGetWindowList();
  153.         /* 
  154.             iterate through windows - we use WindowList 'cos we could
  155.             have made the window invisible and  we lose it - so we
  156.             can't set it back to visible!!
  157.         */
  158.         while (theWindow)
  159.             {
  160.                 GetWTitle(theWindow, windTitle);
  161.                 if (EqualString(windTitle,
  162.                                 nameStr,
  163.                                                 false,
  164.                                                 true))     /* ignore case, don't ignore diacriticals */
  165.                     return(theWindow);
  166.               theWindow = (WindowPtr)((WindowPeek)theWindow)->nextWindow;
  167.             }
  168.         return(theWindow);
  169.     }    /* WindowNameToWindowPtr */
  170.  
  171. pascal WindowPtr GetWindowPtrOfNthWindow(short index)
  172. /* returns a ptr to the window with the given index
  173.   (front window is 1, behind that is 2, etc.).  if
  174.   there's no window with that index (inc. no windows
  175.   at all), returns nil.
  176. */
  177.   {
  178.       WindowPtr theWindow;
  179.         
  180.         theWindow = (WindowPtr)LMGetWindowList();
  181.     
  182.         /* iterate through windows */
  183.         
  184.         while (theWindow)
  185.             {
  186.                 index --;
  187.                 if (index <= 0) 
  188.                     return(theWindow);
  189.                     
  190.               theWindow = (WindowPtr)((WindowPeek)theWindow)->nextWindow;
  191.             }
  192.         return(nil);
  193.     }    /* GetWindowPtrOfNthWindow */
  194.     
  195. pascal short CountWindows(void)
  196.     {
  197.         WindowPtr theWindow;
  198.         short     index;
  199.                 
  200.         index = 0;
  201.         theWindow = (WindowPtr)LMGetWindowList();
  202.     
  203.         /* iterate through windows */
  204.         
  205.         while (theWindow)
  206.             {
  207.                 index++;                    
  208.               theWindow = (WindowPtr)((WindowPeek)theWindow)->nextWindow;
  209.             }
  210.         
  211.         return(index);
  212.         
  213.     } /*CountWindows*/
  214.     
  215. pascal short ItemForNamedFont(Str255 theName)
  216.     {
  217.       Str255  itemName;
  218.         short   limit;
  219.     
  220.         limit = CountMItems(myMenus[fontM]);
  221.         while (limit>0)
  222.             {
  223.                 GetItem(myMenus[fontM],limit, itemName);
  224.                 if (IUEqualString(theName, itemName)==0) 
  225.                     return(limit);
  226.                 else
  227.                     limit--;
  228.             }
  229.         return(0);
  230.     } /*ItemForNamedFont*/
  231.  
  232. /**-----------------------------------------------------------------------
  233.         Name:             DoOpenApp
  234.         Purpose:        Called on startup, creates a new document.
  235.     -----------------------------------------------------------------------**/
  236.  
  237. #pragma segment Main
  238.  
  239. pascal OSErr DoOpenApp(const AppleEvent *message,const AppleEvent *reply,long refcon)
  240.   {
  241. #pragma unused (reply,refcon, message)
  242.     
  243.       DPtr ourDoc;
  244.     
  245.         /*just create a new document*/
  246.         ourDoc = NewDocument(false);
  247.         
  248.         if (ourDoc)
  249.             {
  250.                 ShowWindow(ourDoc->theWindow);
  251.                 return(noErr);
  252.             }
  253.         else
  254.             return(-108);
  255.     }
  256.  
  257. /**-----------------------------------------------------------------------
  258.         Name:             DoOpenDocument
  259.         Purpose:        Open all the documents passed in the Open AppleEvent.
  260. -----------------------------------------------------------------------**/
  261.  
  262. #pragma segment Main
  263.  
  264. pascal OSErr DoOpenDocument(const AppleEvent *message, const AppleEvent *reply, long refcon)            
  265.   {
  266. #pragma unused (reply, refcon)
  267.  
  268.         long        index;
  269.         long        itemsInList;
  270.         AEKeyword   keywd;
  271.         OSErr       err;
  272.         OSErr       ignoreErr;
  273.         AEDescList  docList;
  274.         long        actSize;
  275.         DescType    typeCode;
  276.         FSSpec      theFSSpec;
  277.         
  278.         /*open the specified documents*/
  279.         
  280.         docList.dataHandle = nil;
  281.         
  282.         err = AEGetParamDesc(message, keyDirectObject, typeAEList, &docList);
  283.         
  284.         if (err==noErr)
  285.             err = AECountItems( &docList, &itemsInList) ;
  286.         else
  287.           itemsInList = 0;
  288.             
  289.         for (index = 1; index <= itemsInList; index++)
  290.             if (err==noErr)
  291.                 {
  292.                     err = AEGetNthPtr( &docList, index, typeFSS, &keywd, &typeCode,
  293.                                                          (Ptr)&theFSSpec, sizeof(theFSSpec), &actSize ) ;
  294.                     if (err==noErr)
  295.                       err = OpenOld(theFSSpec);
  296.                 }
  297.     
  298.       if (docList.dataHandle)
  299.             ignoreErr = AEDisposeDesc(&docList);
  300.             
  301.         return(err);
  302.     }
  303.  
  304. /**-----------------------------------------------------------------------
  305.         Name:             MyQuit
  306.         Purpose:        Quit event received- exit the program.
  307.     -----------------------------------------------------------------------**/
  308.  
  309. #pragma segment Main
  310.  
  311. pascal OSErr MyQuit(const AppleEvent *message,const AppleEvent *reply,long refcon)            
  312.     {
  313. #pragma unused (reply,refcon)
  314.     
  315.         DescType saveOpt;
  316.         OSErr    tempErr;
  317.         OSErr    myErr;
  318.         DescType returnedType;
  319.         long     actSize;
  320.         
  321.         saveOpt = kAEAsk; /* the default */
  322.         tempErr = AEGetParamPtr(message,
  323.                                                         keyAESaveOptions,
  324.                                                         typeEnumerated,
  325.                                                         &returnedType,
  326.                                                         (Ptr)&saveOpt,
  327.                                                         sizeof(saveOpt),
  328.                                                         &actSize);
  329.         
  330.         if (saveOpt != kAENo)
  331.             myErr = AEInteractWithUser(kAEDefaultTimeout, nil, nil);
  332.  
  333.       if (myErr == noErr)
  334.             DoQuit(saveOpt);
  335.         
  336.         return(myErr);
  337.     }
  338.  
  339. /**-----------------------------------------------------------------------
  340.         Name:             DoAppleEvent
  341.         Purpose:        Process and despatch the AppleEvent
  342.     -----------------------------------------------------------------------**/
  343.  
  344. #pragma segment Main
  345.  
  346. pascal void DoAppleEvent(EventRecord theEvent)
  347.   {
  348.       OSErr err;
  349.         
  350.       /*should check for your own event message types here - if you have any*/
  351.  
  352.         err = AEProcessAppleEvent(&theEvent);
  353.     }
  354.  
  355. /**-----------------------------------------------------------------------
  356.         Name:             MakeSelfAddress
  357.         Purpose:        Builds an AEAddressDesc for the current process
  358.     -----------------------------------------------------------------------**/
  359.     
  360. pascal OSErr MakeSelfAddress(AEAddressDesc *selfAddress)
  361.   {
  362.       ProcessSerialNumber procSerNum;
  363.     
  364.         procSerNum.highLongOfPSN = 0;
  365.         procSerNum.lowLongOfPSN  = kCurrentProcess;
  366.         
  367.         return(AECreateDesc(typeProcessSerialNumber,
  368.                                                 (Ptr)&procSerNum,
  369.                                               sizeof(procSerNum),
  370.                                                 selfAddress));
  371.         
  372.     } /* MakeSelfAddress */
  373.  
  374. /**--------------------------------------------------------------------
  375.     Name : SendAESetObjProp
  376.     Function : Creates a property object from an object,
  377.                          a property type and its data and sends it to
  378.                          the requested address, and cleans up zapping params too
  379.     --------------------------------------------------------------------**/
  380.  
  381. pascal OSErr SendAESetObjProp(AEDesc        *theObj,
  382.                                                             DescType      theProp,
  383.                                                             AEDesc        *theData,
  384.                                                             AEAddressDesc *toWhom)
  385.                                                      
  386.     {
  387.        AEDesc     propObjSpec;
  388.          AppleEvent myAppleEvent;
  389.          AppleEvent defReply;
  390.          OSErr      myErr;
  391.          OSErr      ignoreErr;
  392.          AEDesc     theProperty;
  393.             
  394.         /* create an object spec that represents the property of the given object */
  395.         
  396.         myErr = AECreateDesc(typeType,
  397.                                                  (Ptr)&theProp,
  398.                                                  sizeof(theProp),
  399.                                                  &theProperty);
  400.         if (myErr==noErr)
  401.             myErr = CreateObjSpecifier(cProperty,
  402.                                                                  theObj,
  403.                                                                  formPropertyID,
  404.                                                                  &theProperty,
  405.                                                                  true,
  406.                                                                  &propObjSpec);    
  407.             
  408.         /* create event */
  409.         
  410.         if (myErr==noErr)
  411.             myErr = AECreateAppleEvent(kAECoreSuite,
  412.                                                                  kAESetData,
  413.                                                                  toWhom,
  414.                                                                  0,
  415.                                                                  0,
  416.                                                                  &myAppleEvent);
  417.             
  418.         /* add prop obj spec to the event */
  419.         
  420.         if (myErr==noErr)
  421.             myErr = AEPutParamDesc(&myAppleEvent, keyDirectObject, &propObjSpec);
  422.         
  423.         /* add prop data to the event */
  424.         
  425.         if (myErr==noErr)
  426.             myErr = AEPutParamDesc(&myAppleEvent,keyAEData, theData);
  427.         
  428.         /* send event */
  429.         
  430.         if (myErr==noErr)
  431.             myErr = AESend(&myAppleEvent,
  432.                                          &defReply,
  433.                                          kAENoReply+kAEAlwaysInteract,
  434.                                          kAENormalPriority,
  435.                                          kAEDefaultTimeout,
  436.                                          nil,
  437.                                          nil);
  438.         
  439.         if (myAppleEvent.dataHandle)
  440.             ignoreErr = AEDisposeDesc(&myAppleEvent);
  441.             
  442.         if (&propObjSpec.dataHandle)
  443.           ignoreErr = AEDisposeDesc(&propObjSpec);
  444.         
  445.         if (theData->dataHandle)
  446.             ignoreErr = AEDisposeDesc(theData);
  447.         
  448.         if (toWhom->dataHandle)
  449.             ignoreErr = AEDisposeDesc(toWhom);
  450.         
  451.         return(myErr);
  452.         
  453.     }    /* SendAESetObjProp */
  454.  
  455. /*----------------------------------------------------------------------------------------------*/
  456. /*
  457.     Private AEObject definitions
  458. */
  459. #pragma segment AECommandHandlers
  460.  
  461. #define typeMyAppl       'BAPP' /* sig of my private token type for the app     - appToken   */
  462. #define typeMyWndw             'BWIN'    /* sig of my private token type for windows     - windowToken   */
  463. #define typeMyText           'BTXT'    /* sig of my private token type for text        - textToken     */
  464. #define typeMyTextProp   'BPRP'    /* sig of my private token type for text properties    - textPropToken */
  465. #define typeMyWindowProp 'WPRP'    /* sig of my private token type for window properties  - windowPropToken */
  466. #define typeMyApplProp   'APRP'    /* sig of my private token type for appl properties    - applPropToken */
  467. #define typeMyMenu       'MTKN' /* sig of my private token type for menus       - menuToken  */
  468. #define typeMyMenuItem   'ITKN' /* sig of my private token type for menus       - menuItemToken  */
  469. #define typeMyMenuProp   'MPRP' /* sig of my private token type for menu properties - menuPropToken  */
  470. #define typeMyItemProp   'IPRP' /* sig of my private token type for menu item properties  - menuItemPropToken  */
  471.     
  472. /* These are entirely private to our app - used only when resolving the object specifier */
  473.     
  474. typedef    ProcessSerialNumber appToken;
  475.     
  476. struct applPropToken{
  477.     appToken tokenApplToken;
  478.     DescType tokenApplProperty;
  479. };
  480.  
  481. typedef struct applPropToken applPropToken;
  482.                                         
  483. typedef    WindowPtr WindowToken;
  484.     
  485. struct windowPropToken{
  486.         WindowToken tokenWindowToken;
  487.         DescType    tokenProperty;
  488.     };
  489.     
  490. typedef struct windowPropToken windowPropToken;
  491.     
  492. struct TextToken{
  493.         WindowPtr tokenWindow;
  494.         short     tokenOffset;
  495.         short     tokenLength;
  496.     };
  497.                     
  498. typedef struct TextToken TextToken;
  499.  
  500. struct textPropToken{
  501.         TextToken propertyTextToken;
  502.         DescType  propertyProperty;
  503.     };
  504.                 
  505. typedef struct textPropToken textPropToken;
  506.  
  507. /* Tokens related to menus */
  508.  
  509. struct MenuToken {
  510.     MenuHandle theTokenMenu;
  511.     short      theTokenID;
  512. };
  513.  
  514. typedef struct MenuToken MenuToken;
  515.  
  516. struct MenuItemToken {
  517.     MenuToken  theMenuToken;
  518.     short      theTokenItem;
  519. };
  520.  
  521. typedef struct MenuItemToken MenuItemToken;
  522.  
  523. struct MenuPropToken {
  524.     MenuToken  theMenuToken;
  525.     DescType   theMenuProp;
  526. };
  527.  
  528. typedef struct MenuPropToken MenuPropToken;
  529.  
  530. struct MenuItemPropToken {
  531.     MenuItemToken  theItemToken;
  532.     DescType       theItemProp;
  533. };
  534.  
  535. typedef struct MenuItemPropToken MenuItemPropToken;
  536.  
  537.  
  538. /*
  539.     Name: GotRequiredParams
  540.     Function: Checks all parameters defined as 'required' have been read
  541. */                            
  542. pascal OSErr GotRequiredParams(const AppleEvent *theAppleEvent)
  543.     {
  544.       OSErr    myErr;
  545.         DescType returnedType;
  546.         Size     actSize;
  547.         
  548.         /* look for the keyMissedKeywordAttr, just to see if it's there */
  549.         
  550.         myErr = AEGetAttributePtr(theAppleEvent,
  551.                                                             keyMissedKeywordAttr,
  552.                                                             typeWildCard,
  553.                                                             &returnedType,
  554.                                                             nil,
  555.                                                             0,
  556.                                                             &actSize);
  557.         
  558.         if (myErr == errAEDescNotFound) 
  559.             return(noErr);            /* attribute not there means we got all req params */
  560.         else 
  561.             if (myErr == noErr)  
  562.                 return(errAEParamMissed);        /* attribute there means missed at least one */
  563.             else 
  564.                 return(myErr);        /* some unexpected arror in looking for the attribute */
  565.     }    /* GotReqiredParams */
  566.  
  567. /**--------------------------------------------------------------------
  568.     Name : SetSelectionOfAppleEventDirectObject
  569.     Function : Resolves the Direct Object into a text token and
  570.                          sets the selection of the specified document to that
  571.                          specified in the direct object.
  572.                          Returns the doc and TEHandle chosen.
  573.     --------------------------------------------------------------------**/
  574.  
  575. pascal OSErr SetSelectionOfAppleEventDirectObject(const AppleEvent *theAppleEvent,
  576.                                                                                                DPtr             *theDocument,
  577.                                                                                                 TEHandle         *theHTE)
  578.     {
  579.         OSErr     myErr;
  580.         DescType  returnedType;
  581.         long      actSize;
  582.         TextToken myTextToken;
  583.         OSErr     paramErr;
  584.         WindowPtr fWin;
  585.                     
  586.         paramErr = AEGetParamPtr( theAppleEvent,
  587.                                                             keyDirectObject,
  588.                                                             typeMyText,
  589.                                                             &returnedType,
  590.                                                       (Ptr)&myTextToken,
  591.                                                             sizeof(myTextToken),
  592.                                                             &actSize);
  593.               
  594.         myErr = GotRequiredParams(theAppleEvent);
  595.         
  596.         /* now let's work on the direct object, if any */
  597.         
  598.         if (paramErr == errAEDescNotFound) 
  599.             {
  600.                 /* no direct object; check we have a window */
  601.                 
  602.                 fWin = FrontWindow();
  603.  
  604.                 if (fWin == nil) 
  605.                     return(-1700); /* Generic Err */
  606.                     
  607.                 *theDocument = DPtrFromWindowPtr(fWin);
  608.                 *theHTE      = (**theDocument).theText;
  609.             }
  610.         
  611.         if (paramErr == noErr) 
  612.             {
  613.                 /* got a text token */
  614.                 
  615.                 *theDocument = DPtrFromWindowPtr(myTextToken.tokenWindow);
  616.                 *theHTE      = (**theDocument).theText;
  617.                 
  618.                 TESetSelect(myTextToken.tokenOffset-1,
  619.                             myTextToken.tokenOffset+myTextToken.tokenLength-1,
  620.                                         *theHTE);
  621.                 
  622.             }
  623.             
  624.         if ((paramErr!=noErr) &&
  625.             (paramErr!=errAEDescNotFound))
  626.              {
  627.                  *theDocument = DPtrFromWindowPtr(FrontWindow());
  628.                  *theHTE      = (**theDocument).theText;
  629.              }
  630.              
  631.      return(myErr);
  632.      
  633.     } /* SetSelectionOfAppleEventDirectObject */
  634.     
  635. /**--------------------------------------------------------------------
  636.     Name             : SetSelectionOfAppleEventObject
  637.     Function     : Resolves the whatObject type of the AppleEvent into a text
  638.                              token and sets the selection to be that specified in the
  639.                              text token.
  640.                              Returns the doc and TEHandle chosen.
  641.     --------------------------------------------------------------------**/
  642.  
  643. pascal OSErr SetSelectionOfAppleEventObject(OSType            whatObject,
  644.                                                                                     const AppleEvent *theAppleEvent,
  645.                                                                                      DPtr             *theDocument,
  646.                                                                                     TEHandle         *theHTE)
  647.     {
  648.         DescType   returnedType;
  649.         long       actSize;
  650.         TextToken  myTextToken;
  651.         OSErr      paramErr;
  652.             
  653.         paramErr  = AEGetParamPtr(theAppleEvent,
  654.                                                             whatObject,
  655.                                                             typeMyText,
  656.                                                             &returnedType,
  657.                                                       (Ptr)&myTextToken,
  658.                                                             sizeof(myTextToken),
  659.                                                             &actSize);
  660.                                       
  661.         if (paramErr == noErr) 
  662.             {
  663.                 /* got a text token */
  664.                 
  665.                 *theDocument = DPtrFromWindowPtr(myTextToken.tokenWindow);
  666.                 *theHTE      = (**theDocument).theText;
  667.                 
  668.                 TESetSelect(myTextToken.tokenOffset-1,
  669.                             myTextToken.tokenOffset+myTextToken.tokenLength-1,
  670.                                         *theHTE);
  671.             }
  672.                              
  673.         return(paramErr);
  674.                  
  675.     } /* SetSelectionOfAppleEventObject */
  676.     
  677. /* -----------------------------------------------------------------------
  678.         Name:             AddErrorTextToReply
  679.         Purpose:        Adds the text to cannot modify subscriber
  680.      -----------------------------------------------------------------------**/
  681.      
  682. pascal void AddErrorTextToReply(const Str255 theText, AppleEvent *reply)
  683.     {
  684.         OSErr myErr;
  685.         
  686.         if (reply->descriptorType!=typeNull)
  687.             myErr = AEPutParamPtr(reply,
  688.                             keyErrorString,
  689.                             typeChar,
  690.                             (Ptr) &theText[1],
  691.                             theText[0]);
  692.     }
  693.     
  694. /* -----------------------------------------------------------------------
  695.         Name:             DoCutEdit
  696.         Purpose:        Performs a cut text operation on the current text selection
  697.      -----------------------------------------------------------------------**/
  698.     
  699. pascal OSErr DoCutEdit(const AppleEvent *theAppleEvent, AppleEvent *reply ,long refCon)
  700.     {
  701. #pragma unused (reply,refCon)
  702.     
  703.       OSErr    myErr;
  704.       TEHandle theHTE;
  705.         DPtr     theDocument;
  706.     
  707.         myErr = SetSelectionOfAppleEventDirectObject(theAppleEvent,&theDocument,&theHTE);
  708.         
  709.         if (myErr==noErr) 
  710.             {            
  711.                 myErr = (OSErr) ZeroScrap();
  712.                 
  713.                 TECut(theHTE);
  714.                 
  715.                 AdjustScrollbars(theDocument, false);
  716.                 DrawPageExtras(theDocument);
  717.                 theDocument->dirty = true;
  718.             }
  719.             
  720.         return(myErr);
  721.     } /* DoCutEdit */
  722.     
  723. /* -----------------------------------------------------------------------
  724.         Name:             DoCopyEdit
  725.         Purpose:        Performs a copy text operation on the text selection specified
  726.                                 by the appleEvent direct object (if any)
  727.      -----------------------------------------------------------------------**/
  728.     
  729. pascal OSErr DoCopyEdit(const AppleEvent *theAppleEvent,AppleEvent *reply, long refCon)
  730.     {
  731. #pragma unused (reply,refCon)
  732.     
  733.       OSErr    myErr;
  734.         TEHandle theHTE;
  735.         DPtr     theDocument;
  736.  
  737.         /*
  738.                 Here we extract the information about what to copy from the
  739.                 directObject - if any
  740.         */
  741.         
  742.         myErr = SetSelectionOfAppleEventDirectObject(theAppleEvent,&theDocument,&theHTE);
  743.         
  744.         if (myErr==noErr) 
  745.             {
  746.                 myErr = (OSErr) ZeroScrap();
  747.                 TECopy(theHTE);     
  748.             }
  749.             
  750.         if (myErr==noErr) 
  751.             {
  752.                 myErr = SetSelectionOfAppleEventObject(keyAEContainer, 
  753.                                                                                              theAppleEvent,
  754.                                                                                              &theDocument,
  755.                                                                                              &theHTE);
  756.                 if (myErr == noErr)
  757.                 {
  758.                     TEStylPaste(theHTE);
  759.         
  760.                     AdjustScrollbars(theDocument, false);
  761.                     DrawPageExtras(theDocument);
  762.                     
  763.                     theDocument->dirty = true;
  764.                 }
  765.             }
  766.             
  767.         return(myErr);
  768.     } /* DoCopyEdit */
  769.     
  770. /* -----------------------------------------------------------------------
  771.         Name:             DoPasteEdit
  772.         Purpose:        Performs a paste text operation on the text selection specified
  773.                                 by the appleEvent direct object (if any)
  774.      -----------------------------------------------------------------------**/
  775.     
  776. pascal OSErr DoPasteEdit(const AppleEvent *theAppleEvent,AppleEvent *reply, long refCon)
  777.     {
  778. #pragma unused (reply,refCon)
  779.     
  780.       OSErr    myErr;
  781.         TEHandle theHTE;
  782.         DPtr     theDocument;
  783.  
  784.         myErr = SetSelectionOfAppleEventDirectObject(theAppleEvent, &theDocument, &theHTE);
  785.         
  786.         if (myErr==noErr)
  787.         {
  788.             TEStylPaste(theHTE);     
  789.             
  790.             AdjustScrollbars(theDocument, false);
  791.             DrawPageExtras(theDocument);
  792.  
  793.             theDocument->dirty = true;
  794.         }
  795.  
  796.         return(myErr);
  797.     } /* DoPasteEdit */
  798.     
  799. /* -----------------------------------------------------------------------
  800.         Name:             DoDeleteEdit
  801.         Purpose:        Performs a delete text operation on the selection specified
  802.                                 by the appleEvent direct object (if any)
  803.      -----------------------------------------------------------------------**/
  804.      
  805. pascal OSErr DoDeleteEdit(const AppleEvent *theAppleEvent,AppleEvent *reply, long refcon)
  806.     {
  807. #pragma unused (reply,refcon)
  808.     
  809.         OSErr     myErr;
  810.         TEHandle theHTE;
  811.         DPtr     theDocument;
  812.             
  813.         myErr = SetSelectionOfAppleEventDirectObject(theAppleEvent, &theDocument, &theHTE);
  814.         
  815.         if (myErr==noErr)
  816.         {
  817.             TEDelete(theHTE);
  818.             
  819.             theDocument->dirty = true;
  820.             AdjustScrollbars(theDocument, false);
  821.             DrawPageExtras(theDocument);
  822.         }
  823.  
  824.         return(myErr);
  825.     } /*DoDeleteEdit*/
  826.     
  827. /* -----------------------------------------------------------------------
  828.         Name:             SetTheFontOfTheTokenText
  829.         Purpose:        Sets the font of the text specified by theTextToken to 
  830.                                 the font in name.
  831.      -----------------------------------------------------------------------**/
  832.      
  833. pascal OSErr SetTheFontOfTheTokenText(TextToken theTextToken, Str255 name)
  834.     {
  835.       DPtr      theDocument;
  836.         short     theNumber;
  837.         short     theItem;
  838.         GrafPtr   oldPort;
  839.         TextStyle newStyle;
  840.         OSErr     myErr;
  841.     
  842.         myErr = noErr;
  843.         GetPort(&oldPort);
  844.         
  845.         theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  846.                 
  847.         GetFNum(name, &theNumber);
  848.         
  849.         theItem = ItemForNamedFont(name); /* returns 0 if failed - i.e. SystemFont */
  850.         
  851.         if (gFontMItem)
  852.             CheckItem(myMenus[fontM], gFontMItem, false);
  853.         
  854.         gFontMItem = theItem;
  855.         CheckItem(myMenus[fontM], gFontMItem, true);
  856.         
  857.         theDocument->theFont = theNumber;
  858.         
  859.         TESetSelect(theTextToken.tokenOffset-1,
  860.                                 theTextToken.tokenOffset+theTextToken.tokenLength-1,
  861.                                 theDocument->theText);
  862.  
  863.         newStyle.tsFont = theNumber;
  864.         TESetStyle(doFont, &newStyle, true, theDocument->theText); 
  865.         
  866.         AdjustScrollbars(theDocument, false);
  867.         DrawPageExtras(theDocument);
  868.         theDocument->dirty = true;
  869.  
  870.         SetPort(oldPort);
  871.     
  872.         return(myErr);
  873.     } /* SetTheFontOfTheTokenText */
  874.     
  875. /* -----------------------------------------------------------------------
  876.         Name:             SetTheSizeOfTheTokenText
  877.         Purpose:        Sets the size of the text specified by theTextToken to 
  878.                                 the size in theSize.
  879.      -----------------------------------------------------------------------**/
  880.      
  881. pascal OSErr SetTheSizeOfTheTokenText(TextToken theTextToken, short theSize)
  882.     {
  883.         DPtr      theDocument;
  884.         GrafPtr   oldPort;
  885.         TextStyle newStyle;
  886.         OSErr     myErr;
  887.     
  888.         myErr = noErr;
  889.         GetPort(&oldPort);
  890.         
  891.         theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  892.                                 
  893.         theDocument->theSize = theSize;
  894.         
  895.         TESetSelect(theTextToken.tokenOffset-1,
  896.                                 theTextToken.tokenOffset+theTextToken.tokenLength-1,
  897.                                 theDocument->theText);
  898.  
  899.         newStyle.tsSize = theSize;
  900.         TESetStyle(doSize, &newStyle, true, theDocument->theText); 
  901.         
  902.         AdjustScrollbars(theDocument, false);
  903.         DrawPageExtras(theDocument);
  904.         theDocument->dirty = true;
  905.  
  906.         SetPort(oldPort);
  907.         return(myErr);
  908.     } /* SetTheSizeOfTheTokenText */
  909.     
  910. /* -----------------------------------------------------------------------
  911.         Name:             SetTheStyleOfTheTokenText
  912.         Purpose:        Sets the style of the text specified by theTextToken to 
  913.                                 the style in theStyle.
  914.      -----------------------------------------------------------------------**/
  915.      
  916. pascal OSErr SetTheStyleOfTheTokenText(const TextToken *theTextToken, Style onStyle, Style offStyle)
  917.     {
  918.       DPtr      theDocument;
  919.         GrafPtr   oldPort;
  920.         TextStyle newStyle;
  921.         short     mode;
  922.         Boolean   wasContinuous;
  923.         OSErr     myErr;
  924.     
  925.         myErr = noErr;
  926.         
  927.         GetPort(&oldPort);
  928.         
  929.         theDocument = DPtrFromWindowPtr(theTextToken->tokenWindow);
  930.                                 
  931.         theDocument->theStyle = onStyle;
  932.         TESetSelect(theTextToken->tokenOffset-1,
  933.                                 theTextToken->tokenOffset+theTextToken->tokenLength-1,
  934.                                 theDocument->theText);
  935.  
  936.         // Check to see if off styles are on for whole selection
  937.         mode = doFace;
  938.         
  939.         wasContinuous = TEContinuousStyle(&mode, &newStyle, theDocument->theText);
  940.         if ((newStyle.tsFace & offStyle) != offStyle) // not off styles are on for all
  941.             {
  942.               // switch on across board so that toggle off will clear all
  943.             newStyle.tsFace  = offStyle - (newStyle.tsFace & offStyle);
  944.                 TESetStyle(doFace+doToggle, &newStyle, false, theDocument->theText); 
  945.             }
  946.             
  947.         newStyle.tsFace  = offStyle;
  948.         TESetStyle(doFace+doToggle, &newStyle,(onStyle==0), theDocument->theText); // toggle all to off
  949.         
  950.         mode = doFace;
  951.         if (onStyle)
  952.             {
  953.                 wasContinuous = TEContinuousStyle(&mode, &newStyle, theDocument->theText);
  954.                 if ((newStyle.tsFace & onStyle) != onStyle) // are they on for only a few chars
  955.                     { 
  956.                         // Need to make all chars have these characteristics
  957.                     
  958.                         newStyle.tsFace = onStyle - (newStyle.tsFace & onStyle); // take out those continuous
  959.                         TESetStyle(doFace+doToggle, &newStyle, true, theDocument->theText);
  960.                     }
  961.                 else
  962.                     TESetStyle(0, &newStyle, true, theDocument->theText); // Just Draw it, no changes
  963.             }
  964.             
  965.         AdjustScrollbars(theDocument, false);
  966.         DrawPageExtras(theDocument);
  967.         theDocument->dirty = true;
  968.         
  969.         SetPort(oldPort);
  970.         
  971.         return(myErr);
  972.     } /* SetTheStyleOfTheTokenText */
  973.  
  974. /* -----------------------------------------------------------------------
  975.         Name:             SetWindowProperty
  976.         Purpose:        Sets the window property specified in theWindowPropToken to
  977.                                 be that supplied in dataDesc.
  978.      -----------------------------------------------------------------------**/
  979.      
  980. pascal OSErr SetWindowProperty(const AEDesc *theWPTokenDesc, const AEDesc *dataDesc)
  981.     {
  982.       Str255          theNewName;
  983.         DPtr            theDocument;
  984.         OSErr           err;
  985.         OSErr           ignoreErr;
  986.         Rect            thePosnRect;
  987.         Boolean         theBoolean;
  988.         TEHandle        theHTE;
  989.         GrafPtr         oldPort;
  990.         Point           thePosn;
  991.         THPrint         theTHPrint;
  992.         windowPropToken theWindowPropToken;
  993.         AEDesc          newDesc;
  994.         AEDesc          tokenDesc;
  995.         Size            tokenSize;
  996.         TextToken       myTextToken;
  997.         short           hOffset;
  998.         short           vOffset;
  999.  
  1000.         err = AECoerceDesc(theWPTokenDesc, typeMyWindowProp, &newDesc);
  1001.         
  1002.         if (err)
  1003.             return(err);
  1004.  
  1005.         GetRawDataFromDescriptor(&newDesc,
  1006.                                                          (Ptr)&theWindowPropToken,
  1007.                                                          sizeof(theWindowPropToken),
  1008.                                                          &tokenSize);
  1009.         
  1010.         ignoreErr = AEDisposeDesc(&newDesc);
  1011.     
  1012.         GetPort(&oldPort);
  1013.         SetPort(theWindowPropToken.tokenWindowToken);
  1014.         
  1015.         theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  1016.         
  1017.         switch (theWindowPropToken.tokenProperty) {
  1018.         
  1019.             case pName:
  1020.                             err = GetPStringFromDescriptor(dataDesc, (char *)theNewName);
  1021.                             if (err==noErr) 
  1022.                                 if (theNewName[0] == 0) 
  1023.                                     err = errAEWrongDataType;
  1024.                                 else
  1025.                                     {
  1026.                                         SetWTitle(theWindowPropToken.tokenWindowToken, theNewName);
  1027.                                         PLstrcpy(theDocument->theFileName, theNewName); /* Should we do this??? */
  1028.                                         theDocument->dirty = true;
  1029.                                     }
  1030.                             break;
  1031.             
  1032.             case pContents:
  1033.                             theHTE = theDocument->theText;
  1034.                             TESetSelect(0, 32000, theHTE);
  1035.                             TEDelete(theHTE);
  1036.                             err = GetStyledTextFromDescIntoTEHandle(dataDesc, theHTE);
  1037.                             theDocument->dirty = true;
  1038.                             break;
  1039.                             
  1040.             case pBounds:
  1041.                             err = GetRectFromDescriptor(dataDesc, &thePosnRect);
  1042.                             /* the rectangle is for the structure region, and is in global coordinates */
  1043.                             /* MoveWindow and SizeWindow apply to the content region, so we have to massage a little */
  1044.             
  1045.                             thePosnRect.top    += (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.top -
  1046.                                                                         (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.top;
  1047.                                                                         
  1048.                             thePosnRect.left   += (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.left -
  1049.                                                                         (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.left;
  1050.                                                                         
  1051.                             thePosnRect.bottom += (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.bottom -
  1052.                                                                         (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.bottom;
  1053.                                                                         
  1054.                             thePosnRect.right  += (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.right -
  1055.                                                                         (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.right;
  1056.                             
  1057.                             if (EmptyRect(&thePosnRect)) 
  1058.                                 err = errAECorruptData;
  1059.                             else
  1060.                                 {
  1061.                                     MoveWindow(theWindowPropToken.tokenWindowToken,
  1062.                                                          thePosnRect.left,
  1063.                                                          thePosnRect.top,
  1064.                                                          false);
  1065.                                     SizeWindow(theWindowPropToken.tokenWindowToken,
  1066.                                                          thePosnRect.right- thePosnRect.left,
  1067.                                                          thePosnRect.bottom-thePosnRect.top,
  1068.                                                          true);
  1069.                                     ResizeWindow(theDocument);
  1070.                                 }
  1071.                             break;
  1072.  
  1073.             case pPosition:
  1074.                             err = GetPointFromDescriptor(dataDesc, &thePosn);
  1075.                             /* the point is for the structure region, and is in global coordinates */
  1076.                             /* MoveWindow applies to the content region, so we have to massage a little */
  1077.                             
  1078.                             hOffset = (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.left -
  1079.                                                 (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.left;
  1080.                                                 
  1081.                             vOffset = (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.top -
  1082.                                                 (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.top;
  1083.                                                 
  1084.                                                 
  1085.                             thePosn.v  += vOffset;
  1086.                             thePosn.h  += hOffset;
  1087.                             
  1088.                             MoveWindow(theWindowPropToken.tokenWindowToken,
  1089.                                                  thePosn.h,
  1090.                                                  thePosn.v,
  1091.                                                  false);
  1092.                                                  
  1093.                             ResizeWindow(theDocument);
  1094.                             break;
  1095.             
  1096.           case pIsZoomed:
  1097.                             err = GetBooleanFromDescriptor(dataDesc, &theBoolean);
  1098.                             if (theBoolean)
  1099.                                 ZoomWindow(qd.thePort,
  1100.                                                      inZoomOut,
  1101.                                                      false);
  1102.                             else
  1103.                                 ZoomWindow(qd.thePort,
  1104.                                                      inZoomIn,
  1105.                                                      false);
  1106.                                                                     
  1107.                             ResizeWindow(theDocument);
  1108.                             break;
  1109.             
  1110.             case pVisible:
  1111.                             err = GetBooleanFromDescriptor(dataDesc, &theBoolean);
  1112.                             if (theBoolean)
  1113.                                 ShowWindow(theWindowPropToken.tokenWindowToken);
  1114.                             else
  1115.                                 HideWindow(theWindowPropToken.tokenWindowToken);
  1116.                             break;
  1117.             
  1118.             case pPageSetup:
  1119.                             err = GetTHPrintFromDescriptor(dataDesc, &theTHPrint);
  1120.                                 
  1121.                             if (theTHPrint) 
  1122.                                 {
  1123.                                     if (theDocument->thePrintSetup) 
  1124.                                         DisposHandle((Handle)theDocument->thePrintSetup);
  1125.                                         
  1126.                                     theDocument->thePrintSetup = theTHPrint;
  1127.                                     theDocument->dirty = true;
  1128.                                     ResizePageSetupForDocument(theDocument);
  1129.                                 }
  1130.                             break;
  1131.  
  1132.             case pSelection:
  1133.                             err = AECoerceDesc(dataDesc, typeMyText, &tokenDesc);
  1134.                             
  1135.                             GetRawDataFromDescriptor(&tokenDesc,
  1136.                                                                              (Ptr)&myTextToken,
  1137.                                                                              sizeof(myTextToken),
  1138.                                                                              &tokenSize);
  1139.                                                                                              
  1140.                             ignoreErr = AEDisposeDesc(&tokenDesc);
  1141.                             
  1142.                             if (err == noErr) 
  1143.                                 {
  1144.                                     /* got a text token */
  1145.                                     
  1146.                                     theDocument = DPtrFromWindowPtr(myTextToken.tokenWindow);
  1147.                                     theHTE      = theDocument->theText;
  1148.                                     
  1149.                                     TESetSelect(myTextToken.tokenOffset-1,
  1150.                                                             myTextToken.tokenOffset+myTextToken.tokenLength-1,
  1151.                                                             theHTE);
  1152.                                 }
  1153.                             break;
  1154.             
  1155.             case pIndex:
  1156.             case pIsModal:
  1157.             case pIsResizable:
  1158.             case pHasTitleBar:
  1159.             case pHasCloseBox:
  1160.             case pIsFloating:
  1161.             case pBestType:
  1162.             case pClass:
  1163.             case pDefaultType:
  1164.             case pIsZoomable:
  1165.             case pIsModified:
  1166.             default:
  1167.                             err = errAEEventNotHandled; /* We don't allow these to be set or we don't understand it*/
  1168.         }
  1169.         
  1170.         SetPort(oldPort);
  1171.         
  1172.         return(err);
  1173.                 
  1174.     } /* SetWindowProperty */
  1175.     
  1176. /* -----------------------------------------------------------------------
  1177.         Name:             AddDescStyleItem
  1178.         Purpose:        Adds the kAEXXXX style to theStyle.
  1179.      -----------------------------------------------------------------------**/
  1180.      
  1181. pascal void AddDescStyleItem(DescType theDesc, Style *theStyle)
  1182.     {
  1183.         if (theDesc == kAEBold)
  1184.             *theStyle = *theStyle+bold;
  1185.         else
  1186.         if (theDesc == kAEItalic)
  1187.             *theStyle = *theStyle+italic;
  1188.         else
  1189.         if (theDesc == kAEUnderline)
  1190.             *theStyle = *theStyle+underline;
  1191.         else
  1192.         if (theDesc == kAEOutline)
  1193.             *theStyle = *theStyle+outline;
  1194.         else
  1195.         if (theDesc == kAEShadow)
  1196.             *theStyle = *theStyle+shadow;
  1197.         else
  1198.         if (theDesc == kAECondensed)
  1199.             *theStyle = *theStyle+condense;
  1200.         else
  1201.         if (theDesc == kAEExpanded)
  1202.             *theStyle = *theStyle+extend;
  1203.         else
  1204.         if (theDesc == kAEPlain)
  1205.             *theStyle = 0;
  1206.     } /* AddDescStyleItem */
  1207.     
  1208. pascal OSErr MakeStyleFromAEList(const AEDescList *styleList, Style *theStyle, Boolean *hadPlain)
  1209.     {
  1210.         OSErr     myErr;
  1211.         DescType  styleDesc;
  1212.         long      itemsInList;
  1213.         long      actSize;
  1214.         AEKeyword keywd;
  1215.         DescType  typeCode;
  1216.             
  1217.         *hadPlain = false;
  1218.         *theStyle = 0;
  1219.         
  1220.       myErr = AECountItems(styleList, &itemsInList);
  1221.         while (itemsInList>0)
  1222.           if (myErr==noErr)
  1223.                 {
  1224.                     myErr  = AEGetNthPtr(styleList,
  1225.                                                              itemsInList,
  1226.                                                              typeEnumerated,
  1227.                                                              &keywd,
  1228.                                                              &typeCode,
  1229.                                                              (Ptr)&styleDesc,
  1230.                                                              sizeof(styleDesc),
  1231.                                                              &actSize);
  1232.                     
  1233.                     AddDescStyleItem(styleDesc, theStyle);
  1234.                     
  1235.                     if (styleDesc == kAEPlain) 
  1236.                       {
  1237.                             itemsInList = 0;
  1238.                             *hadPlain    = true;
  1239.                         }
  1240.                     else
  1241.                       itemsInList--;
  1242.                 }
  1243.                 
  1244.         return(myErr);
  1245.     } /*MakeStyleFromAEList*/
  1246.     
  1247. pascal OSErr GetTextStyles(const AEDesc *dataDesc, Style *onStyles, Style *offStyles)
  1248.     {
  1249.         OSErr      myErr;
  1250.         OSErr      ignoreErr;
  1251.         AEDescList textSDesc;
  1252.         AEDescList onDesc;
  1253.         AEDescList offDesc;
  1254.         Boolean    hadPlain;
  1255.             
  1256.       textSDesc.dataHandle = nil;
  1257.       onDesc.dataHandle    = nil;
  1258.       offDesc.dataHandle   = nil;
  1259.         
  1260.         *onStyles  = 0;
  1261.         *offStyles = 0;
  1262.         
  1263.       myErr = AECoerceDesc(dataDesc, typeAERecord, &textSDesc);
  1264.         
  1265.         if (myErr==noErr)
  1266.           myErr = AEGetKeyDesc(&textSDesc, keyAEOnStyles, typeAEList, &onDesc);
  1267.         
  1268.         if (myErr==noErr)
  1269.           myErr = AEGetKeyDesc(&textSDesc, keyAEOffStyles, typeAEList, &offDesc);
  1270.         
  1271.         if (myErr==noErr)
  1272.             myErr = MakeStyleFromAEList(&onDesc,  onStyles, &hadPlain);
  1273.             
  1274.         if (hadPlain)
  1275.             *offStyles = bold+italic+underline+outline+shadow+condense+extend;
  1276.         else
  1277.             {
  1278.                 if (myErr==noErr)
  1279.                     myErr = MakeStyleFromAEList(&offDesc, offStyles, &hadPlain);
  1280.         
  1281.                 if (hadPlain)
  1282.                     myErr = errAEEventFailed;
  1283.             }
  1284.             
  1285.         if (textSDesc.dataHandle)
  1286.             ignoreErr = AEDisposeDesc(&textSDesc);
  1287.             
  1288.         if (onDesc.dataHandle)
  1289.             ignoreErr = AEDisposeDesc(&onDesc);
  1290.             
  1291.         if (offDesc.dataHandle)
  1292.             ignoreErr = AEDisposeDesc(&offDesc);
  1293.         
  1294.         return(myErr);
  1295.     } /* GetTextStyles */
  1296.  
  1297. /* -----------------------------------------------------------------------
  1298.         Name:             SetTextProperty
  1299.         Purpose:        Sets the text property specfied by theTextPropToken to
  1300.                                 that in dataDesc.
  1301.      -----------------------------------------------------------------------**/
  1302.      
  1303. pascal OSErr SetTextProperty(const AEDesc *tokenDesc, const AEDesc *dataDesc)
  1304.     {
  1305.       TEHandle      theHTE;
  1306.         DPtr          theDoc;
  1307.         Str255        name;
  1308.         short         theSize;
  1309.         OSErr         myErr;
  1310.         OSErr         ignoreErr;
  1311.         Style         onStyle;
  1312.         Style         offStyle;
  1313.         textPropToken theTextPropToken;
  1314.         AEDesc        newDesc;
  1315.         Size          tokenSize;
  1316.         
  1317.       newDesc.dataHandle = nil;
  1318.         
  1319.       myErr = AECoerceDesc(tokenDesc, typeMyTextProp, &newDesc);
  1320.         if (myErr == noErr)
  1321.             {
  1322.                 GetRawDataFromDescriptor(&newDesc,
  1323.                                                                  (Ptr)&theTextPropToken,
  1324.                                                                  sizeof(theTextPropToken),
  1325.                                                                  &tokenSize);
  1326.                 ignoreErr = AEDisposeDesc(&newDesc);
  1327.             }
  1328.         else
  1329.             return(myErr);
  1330.             
  1331.         theDoc = DPtrFromWindowPtr(theTextPropToken.propertyTextToken.tokenWindow);
  1332.         theDoc->dirty = true;
  1333.         
  1334.         switch (theTextPropToken.propertyProperty) {
  1335.         
  1336.             case pContents:
  1337.                         theHTE = theDoc->theText;
  1338.                                     TESetSelect(theTextPropToken.propertyTextToken.tokenOffset-1,
  1339.                                                             theTextPropToken.propertyTextToken.tokenOffset+
  1340.                                                                                     theTextPropToken.propertyTextToken.tokenLength-1,
  1341.                                                             theHTE);
  1342.  
  1343.                                     TEDelete(theHTE);
  1344.                                     myErr = GetStyledTextFromDescIntoTEHandle(dataDesc, theHTE);
  1345.                                     break;
  1346.             
  1347.             case pFont: myErr = GetPStringFromDescriptor(dataDesc, (char *)name);
  1348.                                     
  1349.                                     if (myErr==noErr)
  1350.                                         myErr = SetTheFontOfTheTokenText(theTextPropToken.propertyTextToken,
  1351.                                                                                                          name);
  1352.                                     break;
  1353.             
  1354.           case pPointSize:
  1355.                         myErr = GetIntegerFromDescriptor(dataDesc, &theSize);
  1356.                                     if (myErr==noErr)
  1357.                                         myErr = SetTheSizeOfTheTokenText(theTextPropToken.propertyTextToken,
  1358.                                                                                                           theSize);
  1359.                                     break;
  1360.                                     
  1361.             case pTextStyles:
  1362.                                     onStyle  = 0;
  1363.                                     offStyle = 0;
  1364.                                     
  1365.                                     myErr = GetTextStyles(dataDesc, &onStyle, &offStyle);
  1366.                     
  1367.                                     if (myErr==noErr)
  1368.                                         if (onStyle & offStyle != 0)
  1369.                                             myErr = errAEEventFailed;
  1370.                                         else
  1371.                                             myErr = SetTheStyleOfTheTokenText(&theTextPropToken.propertyTextToken,
  1372.                                                                                                                 onStyle,
  1373.                                                                                                                 offStyle);
  1374.                                     break;
  1375.                                     
  1376.             default: myErr = errAEWrongDataType;
  1377.             
  1378.         }
  1379.                         
  1380.         return(myErr);
  1381.             
  1382.     } /* SetTextProperty */
  1383.     
  1384. /* -----------------------------------------------------------------------
  1385.         Name:             HandleSetData
  1386.         Purpose:        Resolves the object into a token (could be one of many) and
  1387.                                 the sets the data of that object to dataDesc.
  1388.      -----------------------------------------------------------------------**/
  1389.      
  1390. pascal OSErr HandleSetData(const AEDesc *theObj, const AEDesc *dataDesc, AppleEvent *reply)
  1391. {
  1392.   OSErr           myErr;
  1393.   OSErr           ignoreErr;
  1394.     AEDesc          newDesc;
  1395.     DPtr            theDocument;
  1396.     TEHandle        theHTE;
  1397.     TextToken       theTextToken;
  1398.     Size            tokenSize;
  1399.     AEDesc          objTokenDesc;
  1400.     
  1401.     objTokenDesc.dataHandle = nil;
  1402.     newDesc.dataHandle      = nil;
  1403.     
  1404.     /*
  1405.         Coerce theObj into a token which we can use - 
  1406.              set the property or data for that token
  1407.     */
  1408.     
  1409.     myErr = AEResolve(theObj ,kAEIDoMinimum, &objTokenDesc);
  1410.         
  1411.     /* We don't actually allow ANY app property setting, but
  1412.        just incase we'll decode looking for an typeMyApplProp and flag an error -
  1413.          do same for menu related tokens
  1414.     */
  1415.     
  1416.     switch (objTokenDesc.descriptorType) {
  1417.         case typeMyWindowProp: myErr = SetWindowProperty(&objTokenDesc, dataDesc);
  1418.                                                      break;
  1419.         
  1420.         case typeMyTextProp :  myErr = SetTextProperty(&objTokenDesc, dataDesc);
  1421.                                break;
  1422.  
  1423.         case typeMyText:        if (AECoerceDesc(&objTokenDesc, typeMyText, &newDesc) == noErr) 
  1424.                                                         {
  1425.                                                             GetRawDataFromDescriptor(&newDesc,
  1426.                                                                                                              (Ptr)&theTextToken,
  1427.                                                                                                              sizeof(theTextToken),
  1428.                                                                                                              &tokenSize);
  1429.                                                                                                              
  1430.                                                             ignoreErr = AEDisposeDesc(&newDesc);
  1431.                                                                                                              
  1432.                                                             theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  1433.                                                             theHTE            = theDocument->theText;
  1434.                                                             
  1435.                                                             TESetSelect(theTextToken.tokenOffset-1,
  1436.                                                                                     theTextToken.tokenOffset+
  1437.                                                                                                             theTextToken.tokenLength-1,
  1438.                                                                                     theHTE);
  1439.  
  1440.                                                             TEDelete(theHTE);
  1441.                                                                 
  1442.                                                             myErr = GetStyledTextFromDescIntoTEHandle(dataDesc, theHTE);
  1443.                                                                 
  1444.                                                             theDocument->dirty = true;
  1445.                                                         }
  1446.                                                     break;
  1447.                                                     
  1448.         // Read only items and properties and those we don't know
  1449.         case typeMyApplProp:
  1450.         case typeMyMenu:
  1451.         case typeMyMenuProp:
  1452.         case typeMyMenuItem:
  1453.         case typeMyItemProp:                                                        
  1454.         default:            myErr = errAEWrongDataType;
  1455.     }
  1456.     
  1457.     if (objTokenDesc.dataHandle)
  1458.         ignoreErr = AEDisposeDesc(&objTokenDesc);
  1459.     
  1460.     if (myErr == errCantWriteSubscriber)
  1461.         AddErrorTextToReply((unsigned char *)"\pCannot write into subscriber", reply);
  1462.         
  1463.     return(myErr);
  1464. }    /* HandleSetData */
  1465.  
  1466. /*
  1467.     A few convenient FORWARDS...
  1468. */
  1469.  
  1470. pascal OSErr MakeWindowObj( WindowPtr theWindow, AEDesc *dMyDoc);
  1471. pascal OSErr MakeTextObj(WindowPtr theWindow,
  1472.                                                  short     selStart,
  1473.                                                  short     selEnd,
  1474.                                                  AEDesc    *selTextObj);
  1475.  
  1476. pascal OSErr MakeMenuObj(Str255 theName, AEDesc *resultingObj);
  1477. pascal OSErr MakeMenuItemObj(Str255 theName, short theItem, AEDesc *resultingObj);
  1478. pascal OSErr MakeClassObj(DescType theClass, AEDesc *myClassObj);
  1479. /*
  1480.     Back to real code
  1481. */
  1482. pascal OSErr MakeSelTextObj( WindowPtr theWindow,
  1483.                                                          TEHandle  theTextEditHandle,
  1484.                                                          AEDesc    *selTextObj)
  1485. /*
  1486.     This is a hack to get the AppleScript Alpha to work...
  1487. */
  1488.     {
  1489.         OSErr    myErr;
  1490.         OSErr    ignoreErr;
  1491.         AEDesc   dNull;
  1492.         AEDesc   dMyDoc;
  1493.         AEDesc   startOfs;
  1494.         AEDesc   endOfs;
  1495.         AEDesc   startObj;
  1496.         AEDesc   endObj;
  1497.         AEDesc   rangeDesc;
  1498.         long     startChar;
  1499.         long     endChar;
  1500.         Boolean  spotFlag;
  1501.             
  1502.         myErr = noErr;
  1503.         
  1504.         if (theWindow==nil) 
  1505.             return(noErr);
  1506.             
  1507.         selTextObj->dataHandle = nil;
  1508.         dMyDoc.dataHandle      = nil;
  1509.         startObj.dataHandle    = nil;
  1510.         endObj.dataHandle      = nil;
  1511.         
  1512.         /* 
  1513.             make the window object 
  1514.         */
  1515.         
  1516.         myErr = MakeWindowObj(theWindow, &dMyDoc);
  1517.             
  1518.         if (myErr==noErr)
  1519.             {
  1520.                 /* get the start and end of selection */
  1521.                 
  1522.                 startChar = (*theTextEditHandle)->selStart+1;    /* start counting obj's from 1, not 0 */
  1523.                 endChar   = (*theTextEditHandle)->selEnd;
  1524.                 spotFlag  = ((*theTextEditHandle)->selStart == (*theTextEditHandle)->selEnd);
  1525.                     
  1526.                 myErr = CreateOffsetDescriptor(startChar, &startOfs);
  1527.                             
  1528.                 if (myErr==noErr)
  1529.                     if (spotFlag)
  1530.                         myErr = CreateObjSpecifier(cSpot,
  1531.                                                                              &dMyDoc,
  1532.                                                                              formAbsolutePosition, 
  1533.                                                                              &startOfs, 
  1534.                                                                              true, 
  1535.                                                                              selTextObj);
  1536.                     else
  1537.                         {
  1538.                             /* not a spot - must represent as range */
  1539.                             /* make obj for start char */
  1540.                             
  1541.                             myErr = AECreateDesc(typeNull, nil , 0, &dNull);
  1542.                             
  1543.                             myErr = CreateObjSpecifier(cChar,
  1544.                                                        &dNull,
  1545.                                                                                  formAbsolutePosition,
  1546.                                                                                  &startOfs,
  1547.                                                                                  false,
  1548.                                                                                  &startObj);
  1549.                             
  1550.                             if (myErr==noErr) 
  1551.                                 myErr = CreateOffsetDescriptor(endChar, &endOfs);
  1552.                             
  1553.                             if (myErr==noErr) 
  1554.                                 myErr = CreateObjSpecifier(cChar,
  1555.                                                                                      &dNull,
  1556.                                                                                      formAbsolutePosition,
  1557.                                                                                      &endOfs,
  1558.                                                                                      false,
  1559.                                                                                      &endObj);
  1560.                             
  1561.                             if (myErr==noErr) 
  1562.                                 myErr = CreateRangeDescriptor(&startObj,
  1563.                                                                                             &endObj,
  1564.                                                                                             false,
  1565.                                                                                             &rangeDesc);
  1566.                             
  1567.                             if (myErr==noErr) 
  1568.                                 myErr = CreateObjSpecifier(cChar,
  1569.                                                                                      &dMyDoc,
  1570.                                                                                      formRange,
  1571.                                                                                      &rangeDesc,
  1572.                                                                                      true,
  1573.                                                                                      selTextObj);
  1574.                                                                                      
  1575.                             if (startObj.dataHandle)
  1576.                               ignoreErr = AEDisposeDesc(&startObj);
  1577.                                 
  1578.                             if (startOfs.dataHandle)
  1579.                               ignoreErr = AEDisposeDesc(&startOfs);
  1580.                                 
  1581.                             if (endObj.dataHandle)
  1582.                               ignoreErr = AEDisposeDesc(&endObj);
  1583.                                 
  1584.                             if (endOfs.dataHandle)
  1585.                               ignoreErr = AEDisposeDesc(&endOfs);
  1586.                         }
  1587.             }
  1588.             
  1589.         return(myErr);
  1590.     }    /* MakeSelTextObj */
  1591.  
  1592. /* -----------------------------------------------------------------------
  1593.         Name:             DoSetData
  1594.         Purpose:        Handles the SetData Apple Event, extracting the direct
  1595.                                 object (which says what to set) and the data (what to set
  1596.                                 it to).
  1597.      -----------------------------------------------------------------------**/
  1598.      
  1599. pascal OSErr DoSetData(const AppleEvent *theAppleEvent,
  1600.                                                AppleEvent *reply,
  1601.                                                          long        handlerRefCon)
  1602.   {
  1603. #pragma unused (reply, handlerRefCon)
  1604.     
  1605.         OSErr  myErr;
  1606.         OSErr  ignoreErr;
  1607.         AEDesc myDirObj;
  1608.         AEDesc myDataDesc;
  1609.         
  1610.         myDataDesc.dataHandle = nil;
  1611.         myDirObj.dataHandle   = nil;
  1612.                 
  1613.         /* pick up the direct object, which is the object whose data is to be set */
  1614.         
  1615.         myErr = AEGetParamDesc(theAppleEvent,
  1616.                                                      keyDirectObject,
  1617.                                                      typeWildCard,
  1618.                                                      &myDirObj);
  1619.             
  1620.         /* now the data to set it to - typeWildCard means get as is*/
  1621.         if (myErr == noErr) 
  1622.             myErr = AEGetParamDesc( theAppleEvent,
  1623.                                                             keyAEData,
  1624.                                                             typeWildCard,
  1625.                                                             &myDataDesc);
  1626.         
  1627.         /* missing any parameters? */
  1628.         if (myErr == noErr) 
  1629.             myErr = GotRequiredParams(theAppleEvent);
  1630.         
  1631.         /* set the data */
  1632.         if (myErr == noErr) 
  1633.             myErr = HandleSetData(&myDirObj, &myDataDesc, reply);
  1634.             
  1635.         if (myDataDesc.dataHandle)
  1636.             ignoreErr = AEDisposeDesc(&myDataDesc);
  1637.             
  1638.         if (myDirObj.dataHandle)
  1639.             ignoreErr = AEDisposeDesc(&myDirObj);
  1640.   
  1641.         return(myErr);
  1642.     }    /* DoSetData */
  1643.     
  1644. pascal void StyleTokConst(short theStyleItem, DescType *thekConst)
  1645.     {
  1646.         switch (theStyleItem) {
  1647.           case bold      : *thekConst = kAEBold;
  1648.                                              break;
  1649.       case italic    : *thekConst = kAEItalic;
  1650.                                              break;
  1651.       case underline : *thekConst = kAEUnderline;
  1652.                                              break;
  1653.       case outline   : *thekConst = kAEOutline;
  1654.                                              break;
  1655.             case shadow    : *thekConst = kAEShadow;
  1656.                                              break;
  1657.             case condense  : *thekConst = kAECondensed;
  1658.                                              break;
  1659.             case extend    : *thekConst = kAEExpanded;
  1660.                                              break;
  1661.         }
  1662.     } /*StyleTokConst*/
  1663.     
  1664. pascal OSErr BuildTypeTextStylesDesc(Style onStyles, Style offStyles, AEDesc *resultDesc)
  1665.     {
  1666.  
  1667.         OSErr     myErr;
  1668.         OSErr     ignoreErr;
  1669.         short     myStyleItem;
  1670.         DescType  styleConst;
  1671.         AEDesc    onStylesDesc;
  1672.         AEDesc    offStylesDesc;
  1673.         AEDesc    dataDesc;
  1674.         
  1675.         onStylesDesc.dataHandle  = nil;
  1676.         offStylesDesc.dataHandle = nil;
  1677.         dataDesc.dataHandle  = nil;
  1678.     
  1679.         myErr = AECreateList(nil, 0, true,  &dataDesc);
  1680.         
  1681.         myErr = AECreateList(nil, 0, false, &onStylesDesc);
  1682.         myErr = AECreateList(nil, 0, false, &offStylesDesc);
  1683.         
  1684.         for (myStyleItem = bold; myStyleItem<=extend; myStyleItem = myStyleItem <<1)
  1685.             if (myErr==noErr)
  1686.                 {
  1687.                     StyleTokConst(myStyleItem, &styleConst);
  1688.                     if (myStyleItem & onStyles)
  1689.                         myErr  = AEPutPtr(&onStylesDesc,
  1690.                                                             0,                /*add to end of list*/
  1691.                                                             typeEnumerated, /* text for style name */
  1692.                                                             (Ptr)&styleConst,
  1693.                                                             sizeof(styleConst));
  1694.                     
  1695.                     if (myStyleItem & offStyles)
  1696.                         myErr  = AEPutPtr(&offStylesDesc,
  1697.                                                             0,                /*add to end of list*/
  1698.                                                             typeEnumerated, /* text for style name */
  1699.                                                             (Ptr)&styleConst,
  1700.                                                             sizeof(styleConst));
  1701.             }
  1702.         
  1703.         if (myErr==noErr)
  1704.             myErr = AEPutKeyDesc(&dataDesc, keyAEOnStyles,  &onStylesDesc);
  1705.         
  1706.         if (myErr==noErr)
  1707.             myErr = AEPutKeyDesc(&dataDesc, keyAEOffStyles, &offStylesDesc);
  1708.         
  1709.         if (myErr==noErr)
  1710.             myErr = AECoerceDesc(&dataDesc, typeTextStyles, resultDesc);
  1711.             
  1712.         if (onStylesDesc.dataHandle)
  1713.             ignoreErr = AEDisposeDesc(&onStylesDesc);
  1714.             
  1715.         if (offStylesDesc.dataHandle)
  1716.             ignoreErr = AEDisposeDesc(&offStylesDesc);
  1717.             
  1718.         if (dataDesc.dataHandle)
  1719.             ignoreErr = AEDisposeDesc(&dataDesc);
  1720.     
  1721.         return(myErr);
  1722.     }
  1723.  
  1724. pascal OSErr BuildTextStylesDesc(Style theStyle, AEDesc *resultDesc)
  1725.     {
  1726.         short     myStyleItem;
  1727.         Style     onStyles;
  1728.         Style     offStyles;
  1729.                 
  1730.         onStyles  = 0;
  1731.         offStyles = 0;
  1732.         
  1733.         for (myStyleItem = bold; myStyleItem<=extend; myStyleItem = myStyleItem <<1)
  1734.             {
  1735.                 if (myStyleItem & theStyle)
  1736.                     onStyles  = onStyles  + myStyleItem;
  1737.                 else
  1738.                     offStyles = offStyles + myStyleItem;
  1739.             }
  1740.     
  1741.         return(BuildTypeTextStylesDesc(onStyles, offStyles, resultDesc));
  1742.         
  1743.     } /* BuildTextStylesDesc */
  1744.         
  1745. pascal OSErr BuildStyledTextDesc(TEHandle theHTE, short start, short howLong, AEDesc *resultDesc)
  1746.     {
  1747.         AEDesc       listDesc;
  1748.         short        oldSelStart;
  1749.         short        oldSelEnd;
  1750.         StScrpHandle myStScrpHandle;
  1751.         OSErr        myErr;
  1752.         OSErr        ignoreErr;
  1753.         
  1754.         listDesc.dataHandle = nil;
  1755.         
  1756.         oldSelStart = (**theHTE).selStart;
  1757.         oldSelEnd   = (**theHTE).selEnd;
  1758.         
  1759.         TESetSelect(start-1, start+howLong-2, theHTE);
  1760.         
  1761.         myErr = AECreateList(nil, 0, true,  &listDesc);
  1762.         
  1763.         HLock((Handle)(**theHTE).hText);
  1764.                                                          
  1765.         if (myErr==noErr)
  1766.             myErr = AEPutKeyPtr(&listDesc,
  1767.                                 keyAEText,
  1768.                                                     typeChar,
  1769.                                                     (Ptr)&(*(**theHTE).hText)[start-1],
  1770.                                                     howLong);
  1771.                                                     
  1772.         HUnlock((Handle)(**theHTE).hText);
  1773.         
  1774.         myStScrpHandle = GetStylScrap(theHTE);
  1775.         
  1776.         if (myStScrpHandle)
  1777.             {
  1778.                 HLock((Handle)myStScrpHandle);
  1779.                 
  1780.                 if (myErr==noErr)
  1781.                     myErr = AEPutKeyPtr(&listDesc,
  1782.                                         keyAEStyles,
  1783.                                                             typeScrapStyles,
  1784.                                                             (Ptr)*myStScrpHandle,
  1785.                                                             GetHandleSize((Handle)myStScrpHandle));
  1786.                     
  1787.                 HUnlock((Handle)myStScrpHandle);
  1788.             }    
  1789.         else
  1790.             myErr = AEPutKeyPtr(&listDesc,
  1791.                                                     keyAEStyles,
  1792.                                                     typeScrapStyles,
  1793.                                                     (Ptr)nil,
  1794.                                                     0);
  1795.         
  1796.         if (myErr==noErr)
  1797.             myErr = AECoerceDesc(&listDesc, typeStyledText, resultDesc); // should be typeIntlText
  1798.         
  1799.         if (listDesc.dataHandle)
  1800.             ignoreErr = AEDisposeDesc(&listDesc);
  1801.         
  1802.         TESetSelect(oldSelStart, oldSelEnd, theHTE);
  1803.         
  1804.         return(myErr);
  1805.     }
  1806.     
  1807. /* -----------------------------------------------------------------------
  1808.         Name:             GetTextProperty
  1809.         Purpose:        Fills dataDesc with the requested text property.
  1810.      -----------------------------------------------------------------------**/
  1811.      
  1812. pascal OSErr GetTextProperty(const AEDesc *theTokenDesc, AEDesc *dataDesc)
  1813.     {
  1814.       DPtr          theDocument;
  1815.         TEHandle      theHTE;
  1816.         Str255        fontName;
  1817.         short         theSize;
  1818.         GrafPtr       oldPort;
  1819.         TextStyle     theTextStyle;
  1820.         short         lineHeight;
  1821.         short         fontAscent;
  1822.         textPropToken theTextPropToken;
  1823.         OSErr         myErr;
  1824.         OSErr                    ignoreErr;
  1825.         Size          tokenSize;
  1826.         AEDesc        newDesc;
  1827.         
  1828.       myErr = AECoerceDesc(theTokenDesc, typeMyTextProp, &newDesc);
  1829.         if (myErr == noErr)
  1830.             {
  1831.                 GetRawDataFromDescriptor(&newDesc,
  1832.                                                                  (Ptr)&theTextPropToken,
  1833.                                                                  sizeof(theTextPropToken),
  1834.                                                                  &tokenSize);
  1835.                 ignoreErr= AEDisposeDesc(&newDesc);                                                 
  1836.             }
  1837.         else
  1838.           return(myErr);
  1839.  
  1840.         /*
  1841.             For each property we build a descriptor to be returned as the reply.
  1842.         */
  1843.                 
  1844.         theDocument = DPtrFromWindowPtr(theTextPropToken.propertyTextToken.tokenWindow);
  1845.         theHTE             = theDocument->theText;
  1846.         
  1847.         TEGetStyle (theTextPropToken.propertyTextToken.tokenOffset-1,
  1848.                                 &theTextStyle,
  1849.                                 &lineHeight,
  1850.                                 &fontAscent,
  1851.                                 theHTE);
  1852.                                         
  1853.         switch (theTextPropToken.propertyProperty){ 
  1854.  
  1855.             case pContents:
  1856.             
  1857.                     myErr = BuildStyledTextDesc(theHTE,
  1858.                                                                             theTextPropToken.propertyTextToken.tokenOffset,
  1859.                                                                             theTextPropToken.propertyTextToken.tokenLength,
  1860.                                                                             dataDesc);
  1861.                     break;
  1862.             
  1863.             case pFont:
  1864.             
  1865.                     GetFontName(theTextStyle.tsFont, fontName);
  1866.                     
  1867.                     myErr = AECreateDesc(typeChar,
  1868.                                                              (Ptr)&fontName[1],
  1869.                                                              fontName[0],
  1870.                                                              dataDesc);
  1871.                     break;
  1872.                     
  1873.             case pTextStyles:
  1874.             
  1875.                     myErr = BuildTextStylesDesc(theTextStyle.tsFace, dataDesc);
  1876.                     break;
  1877.  
  1878.             case pPointSize:
  1879.  
  1880.                     myErr =CreateOffsetDescriptor(theTextStyle.tsSize, dataDesc);
  1881.                     break;
  1882.                     
  1883.             case pScriptTag:
  1884.                     
  1885.                     myErr = CreateOffsetDescriptor(smSystemScript, dataDesc);
  1886.                     break;
  1887.             
  1888.             case pStringWidth:
  1889.                 
  1890.                     GetPort(&oldPort);
  1891.                     SetPort(theTextPropToken.propertyTextToken.tokenWindow);
  1892.                     
  1893.                     HLock((Handle)(**theHTE).hText);
  1894.                     theSize = TextWidth(&(**theHTE).hText,
  1895.                                                             theTextPropToken.propertyTextToken.tokenOffset-1,
  1896.                                                             theTextPropToken.propertyTextToken.tokenLength);
  1897.                     
  1898.                     HUnlock((Handle)(**theHTE).hText);
  1899.                     
  1900.                     SetPort(oldPort);
  1901.                     myErr = CreateOffsetDescriptor(theSize, dataDesc);
  1902.                     
  1903.                     break;
  1904.             
  1905.             case pColor:
  1906.             
  1907.                     myErr = AECreateDesc(typeRGBColor,
  1908.                                                              (Ptr)&theTextStyle.tsColor,
  1909.                                                              sizeof(theTextStyle.tsColor),
  1910.                                                              dataDesc);
  1911.                     break;
  1912.  
  1913.             case pDefaultType:
  1914.             case pBestType:
  1915.             
  1916.                     myErr = MakeTextObj(theTextPropToken.propertyTextToken.tokenWindow,
  1917.                                                          theTextPropToken.propertyTextToken.tokenOffset-1,
  1918.                                                          theTextPropToken.propertyTextToken.tokenOffset+
  1919.                                                          theTextPropToken.propertyTextToken.tokenLength-1,
  1920.                                                          dataDesc);
  1921.                     break;
  1922.  
  1923.             case pClass:
  1924.             
  1925.                     myErr = MakeClassObj(cChar, dataDesc);
  1926.                     break;
  1927.                     
  1928.             default:
  1929.                     myErr = errAEEventNotHandled;
  1930.         }
  1931.         return(myErr);
  1932.         
  1933.     } /*GetTextProperty*/
  1934.     
  1935. /* -----------------------------------------------------------------------
  1936.         Name:             GetWindowProperty
  1937.         Purpose:        Fills dataDesc with the requested window property.
  1938.      -----------------------------------------------------------------------**/
  1939. typedef Rect **RectHandle;
  1940.  
  1941. pascal OSErr GetWindowProperty(const AEDesc *theWPTokenObj, AEDesc *dataDesc)
  1942.   {             
  1943.     OSErr           theErr;
  1944.         OSErr           ignoreErr;
  1945.         Str255          theName;
  1946.         Boolean         theBoolean;
  1947.         Rect            theRect;
  1948.         Point           thePoint;
  1949.         Rect            winRect;
  1950.         Rect            userRect;
  1951.         short           theIndex;
  1952.         DPtr            theDocument;
  1953.         TEHandle        theHTE;
  1954.         windowPropToken theWindowPropToken;
  1955.         AEDesc          newDesc;
  1956.         Size            tokenSize;
  1957.         
  1958.       theErr = AECoerceDesc(theWPTokenObj,typeMyWindowProp, &newDesc);
  1959.         
  1960.         if (theErr == noErr)
  1961.             {
  1962.                 GetRawDataFromDescriptor(&newDesc,
  1963.                                                                  (Ptr)&theWindowPropToken,
  1964.                                                                  sizeof(theWindowPropToken),
  1965.                                                                  &tokenSize);
  1966.                                                                  
  1967.                 ignoreErr = AEDisposeDesc(&newDesc);
  1968.             }
  1969.         else
  1970.           return(theErr);
  1971.             
  1972.         switch (theWindowPropToken.tokenProperty) { 
  1973.             
  1974.             case pName:
  1975.             
  1976.                 GetWTitle(theWindowPropToken.tokenWindowToken, theName);
  1977.                 theErr = AECreateDesc(typeChar,
  1978.                                                             (Ptr)&theName[1],
  1979.                                                             theName[0],
  1980.                                                             dataDesc);
  1981.                 break;
  1982.             
  1983.             case pContents:
  1984.             
  1985.                 theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  1986.                 theHTE      = theDocument->theText;
  1987.                 
  1988.                 theErr = BuildStyledTextDesc( theHTE,
  1989.                                                                             1,
  1990.                                                                             (**theHTE).teLength,
  1991.                                                                             dataDesc);
  1992.                 break;
  1993.             
  1994.             case pBounds:
  1995.             
  1996.                 SetPort(theWindowPropToken.tokenWindowToken);
  1997.  
  1998.                 theRect = (*((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn)->rgnBBox;
  1999.                 
  2000.                 theErr  = AECreateDesc(typeQDRectangle,
  2001.                                                              (Ptr)&theRect,
  2002.                                                              sizeof(theRect),
  2003.                                                              dataDesc);
  2004.                 break;
  2005.             
  2006.             case pPosition:
  2007.             
  2008.                 thePoint.v = (*((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn)->rgnBBox.top;
  2009.                 thePoint.h = (*((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn)->rgnBBox.left;
  2010.                             
  2011.                 theErr   = AECreateDesc(typeQDPoint,
  2012.                                                               (Ptr)&thePoint,
  2013.                                                               sizeof(thePoint),
  2014.                                                               dataDesc);
  2015.                 break;
  2016.                         
  2017.             case pVisible:
  2018.             
  2019.                 theBoolean = ((WindowPeek)theWindowPropToken.tokenWindowToken)->visible;
  2020.                                 
  2021.                 theErr  = AECreateDesc(typeBoolean,
  2022.                                                              (Ptr)&theBoolean,
  2023.                                                              sizeof(theBoolean),
  2024.                                                              dataDesc);
  2025.                 break;
  2026.             
  2027.             case pIsModal:
  2028.             
  2029.                 theBoolean = false;
  2030.                                 
  2031.                 theErr  = AECreateDesc(typeBoolean,
  2032.                                                              (Ptr)&theBoolean,
  2033.                                                              sizeof(theBoolean),
  2034.                                                              dataDesc);
  2035.                 break;
  2036.  
  2037.             case pIsZoomed:
  2038.             
  2039.                 if (((WindowPeek)theWindowPropToken.tokenWindowToken)->spareFlag) 
  2040.                     {
  2041.                         SetPort(theWindowPropToken.tokenWindowToken);
  2042.                         
  2043.                         userRect = **((RectHandle)((WindowPeek)qd.thePort)->dataHandle);
  2044.                         winRect  = qd.thePort->portRect;
  2045.                         LocalToGlobal((Point *)&winRect.top);
  2046.                         LocalToGlobal((Point *)&winRect.bottom);
  2047.                         
  2048.                         theBoolean = !EqualRect(&userRect, &winRect);
  2049.                     }
  2050.                 else
  2051.                     theBoolean = false;
  2052.                                 
  2053.                 theErr  = AECreateDesc(typeBoolean,
  2054.                                                              (Ptr)&theBoolean,
  2055.                                                              sizeof(theBoolean),
  2056.                                                              dataDesc);
  2057.                 break;
  2058.             
  2059.             case pIsResizable:
  2060.             case pHasTitleBar:
  2061.             case pHasCloseBox:
  2062.             case pIsZoomable :
  2063.             
  2064.                 theBoolean = true;
  2065.                                 
  2066.                 theErr  = AECreateDesc(typeBoolean,
  2067.                                                              (Ptr)&theBoolean,
  2068.                                                              sizeof(theBoolean),
  2069.                                                              dataDesc);
  2070.                 break;
  2071.         
  2072.             case pIsFloating:
  2073.             
  2074.                 theBoolean = false;
  2075.                                 
  2076.                 theErr  = AECreateDesc(typeBoolean,
  2077.                                                              (Ptr)&theBoolean,
  2078.                                                              sizeof(theBoolean),
  2079.                                                              dataDesc);
  2080.                 break;
  2081.             
  2082.             case pIsModified:
  2083.             
  2084.                 theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  2085.                 
  2086.                 theBoolean  = theDocument->dirty;
  2087.                 
  2088.                 theErr  = AECreateDesc(typeBoolean,
  2089.                                                              (Ptr)&theBoolean,
  2090.                                                              sizeof(theBoolean),
  2091.                                                              dataDesc);
  2092.                 break;
  2093.             
  2094.             case pIndex:
  2095.             
  2096.                 theIndex = 0;
  2097.                 if (theWindowPropToken.tokenWindowToken) 
  2098.                     do
  2099.                         theIndex++;
  2100.                     while (theWindowPropToken.tokenWindowToken != GetWindowPtrOfNthWindow(theIndex));
  2101.                                 
  2102.                 theErr  = AECreateDesc(typeShortInteger,
  2103.                                                              (Ptr)&theIndex,
  2104.                                                              sizeof(theIndex),
  2105.                                                              dataDesc);
  2106.                 break;
  2107.             
  2108.             case pPageSetup:
  2109.             
  2110.                 theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  2111.                 
  2112.                 HLock((Handle)theDocument->thePrintSetup);
  2113.                 
  2114.                 theErr  = AECreateDesc(typeTPrint,
  2115.                                                              (Ptr)*(theDocument->thePrintSetup),
  2116.                                                              sizeof(TPrint),
  2117.                                                              dataDesc);
  2118.                                                              
  2119.                 HUnlock((Handle)theDocument->thePrintSetup);
  2120.                                                              
  2121.                 break;
  2122.             
  2123.             case pSelection:
  2124.             
  2125.                 theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  2126.                 
  2127.                 theErr  = MakeSelTextObj( theWindowPropToken.tokenWindowToken,
  2128.                                                                     theDocument->theText, 
  2129.                                                                     dataDesc);                                                             
  2130.                 break;
  2131.             
  2132.             case pDefaultType:
  2133.             case pBestType:
  2134.             
  2135.                 theErr  = MakeWindowObj(theWindowPropToken.tokenWindowToken,
  2136.                                                                 dataDesc);                                                             
  2137.                 break;
  2138.             
  2139.             case pClass:
  2140.             
  2141.                 theErr  = MakeClassObj(cWindow, dataDesc);                                                             
  2142.                 break;
  2143.                 
  2144.         default:
  2145.                 theErr = errAEEventNotHandled;
  2146.         }
  2147.         return(theErr);
  2148.     } /* GetWindowProperty */
  2149.     
  2150. /** -----------------------------------------------------------------------
  2151.         Name:             GetApplicationProperty
  2152.         Purpose:        Fills dataDesc with the requested application property.
  2153.      -----------------------------------------------------------------------**/
  2154.      
  2155. pascal OSErr GetApplicationProperty(const AEDesc *theObjToken, AEDesc *dataDesc)
  2156.     {
  2157.       OSErr         theErr;
  2158.         OSErr         ignoreErr;
  2159.         Str255        theName;
  2160.         Boolean       isFront;
  2161.         applPropToken theApplPropToken;
  2162.         AEDesc        newDesc;
  2163.         Size          tokenSize;
  2164.         
  2165.         theErr = AECoerceDesc(theObjToken, typeMyApplProp, &newDesc);
  2166.         if (theErr==noErr)
  2167.             {
  2168.                 GetRawDataFromDescriptor(&newDesc,
  2169.                                                                  (Ptr)&theApplPropToken,
  2170.                                                                  sizeof(theApplPropToken),
  2171.                                                                  &tokenSize);
  2172.                                                                  
  2173.                 ignoreErr = AEDisposeDesc(&newDesc);
  2174.             }
  2175.         else
  2176.           return(theErr);
  2177.  
  2178.         theErr = kAEGenericErr;
  2179.         
  2180.         switch (theApplPropToken.tokenApplProperty) {
  2181.         
  2182.             case pName:
  2183.             
  2184.                     PLstrcpy((StringPtr)theName, (unsigned char *)"\pMenuScripter");
  2185.                     theErr  = AECreateDesc(typeChar,
  2186.                                                                  (Ptr)&theName[1],
  2187.                                                                  theName[0],
  2188.                                                                  dataDesc);
  2189.                     break;
  2190.             
  2191.             case pVersion:
  2192.             
  2193.                     PLstrcpy((StringPtr)theName, (unsigned char *)"\p1.0d4");
  2194.                     theErr  = AECreateDesc(typeChar,
  2195.                                                                  (Ptr)&theName[1],
  2196.                                                                  theName[0],
  2197.                                                                  dataDesc);
  2198.                     break;
  2199.         
  2200.             case pIsFrontProcess:
  2201.             
  2202.                     isFront = !gInBackground;
  2203.                     theErr  = AECreateDesc(typeBoolean,
  2204.                                                                  (Ptr)&isFront,
  2205.                                                                  sizeof(isFront),
  2206.                                                                  dataDesc);
  2207.                     break;
  2208.         
  2209.             case pDefaultType:
  2210.             case pBestType:
  2211.             
  2212.                     theErr  = AECreateDesc(typeNull,
  2213.                                                                  nil,
  2214.                                                                  0,
  2215.                                                                  dataDesc);
  2216.                     break;
  2217.             
  2218.             case pClass: 
  2219.             
  2220.                     theErr  = MakeClassObj(cApplication, dataDesc);
  2221.                     break;
  2222.             
  2223.             default:
  2224.             
  2225.                     theErr = errAEEventNotHandled;
  2226.         }
  2227.         
  2228.         return(theErr);
  2229.         
  2230.     } /* GetApplicationProperty */
  2231.      
  2232. /** -----------------------------------------------------------------------
  2233.         Name:             GetMenuProperty
  2234.         Purpose:        Fills dataDesc with the requested menu property.
  2235.      -----------------------------------------------------------------------**/
  2236.      
  2237. pascal OSErr GetMenuProperty(const AEDesc *theObjToken, AEDesc *dataDesc)
  2238.     {
  2239.       OSErr         theErr;
  2240.         OSErr         ignoreErr;
  2241.         Str255        theName;
  2242.         MenuPropToken theMenuPropToken;
  2243.         AEDesc        newDesc;
  2244.         Size          tokenSize;
  2245.         short         activeItem;
  2246.         
  2247.         theErr = AECoerceDesc(theObjToken, typeMyMenuProp, &newDesc);
  2248.         if (theErr==noErr)
  2249.             {
  2250.                 GetRawDataFromDescriptor(&newDesc,
  2251.                                                                  (Ptr)&theMenuPropToken,
  2252.                                                                  sizeof(theMenuPropToken),
  2253.                                                                  &tokenSize);
  2254.                                                                  
  2255.                 ignoreErr = AEDisposeDesc(&newDesc);
  2256.             }
  2257.         else
  2258.           return(theErr);
  2259.  
  2260.         switch (theMenuPropToken.theMenuProp) {
  2261.             case pName : 
  2262.             
  2263.                     PLstrcpy(theName, (**theMenuPropToken.theMenuToken.theTokenMenu).menuData);
  2264.                     theErr  = AECreateDesc(typeChar,
  2265.                                                                  (Ptr)&theName[1],
  2266.                                                                  theName[0],
  2267.                                                                  dataDesc);
  2268.                     break;
  2269.                 
  2270.             case pMenuID:
  2271.             
  2272.                     theErr  = AECreateDesc(typeShortInteger,
  2273.                                                                  (Ptr)&theMenuPropToken.theMenuToken.theTokenID,
  2274.                                                                  sizeof(theMenuPropToken.theMenuToken.theTokenID),
  2275.                                                                  dataDesc);
  2276.                     break;
  2277.                     
  2278.             case pActiveItem:
  2279.             
  2280.                     activeItem = GetScriptActiveItem();
  2281.                 
  2282.                     theErr  = AECreateDesc(typeShortInteger,
  2283.                                                                  (Ptr)&activeItem,
  2284.                                                                  sizeof(activeItem),
  2285.                                                                  dataDesc);
  2286.                     break;    
  2287.             
  2288.             case pDefaultType:
  2289.             case pBestType:
  2290.             
  2291.                     PLstrcpy(theName, (**theMenuPropToken.theMenuToken.theTokenMenu).menuData);
  2292.                     
  2293.                     theErr  = MakeMenuObj(theName, dataDesc);
  2294.                     break;
  2295.             
  2296.             case pClass:
  2297.             
  2298.                     theErr  = MakeClassObj(cMenu, dataDesc);
  2299.                     
  2300.                     break;
  2301.                     
  2302.          default:
  2303.                     theErr = errAEEventNotHandled;
  2304.         }
  2305.         
  2306.         return(theErr);
  2307.     } /* GetMenuProperty */
  2308.     
  2309. /** -----------------------------------------------------------------------
  2310.         Name:             GetMenuItemProperty
  2311.         Purpose:        Fills dataDesc with the requested menu property.
  2312.      -----------------------------------------------------------------------**/
  2313.      
  2314. pascal OSErr GetMenuItemProperty(const AEDesc *theObjToken, AEDesc *dataDesc)
  2315.     {
  2316.       OSErr             theErr;
  2317.         OSErr             ignoreErr;
  2318.         Str255            theName;
  2319.         MenuItemPropToken theMenuItemPropToken;
  2320.         AEDesc            newDesc;
  2321.         Size              tokenSize;
  2322.         
  2323.         theErr = AECoerceDesc(theObjToken, typeMyItemProp, &newDesc);
  2324.         if (theErr==noErr)
  2325.             {
  2326.                 GetRawDataFromDescriptor(&newDesc,
  2327.                                                                  (Ptr)&theMenuItemPropToken,
  2328.                                                                  sizeof(theMenuItemPropToken),
  2329.                                                                  &tokenSize);
  2330.                                                                  
  2331.                 ignoreErr = AEDisposeDesc(&newDesc);
  2332.             }
  2333.         else
  2334.           return(theErr);
  2335.  
  2336.         switch (theMenuItemPropToken.theItemProp) {
  2337.         
  2338.             case pName :
  2339.                             GetItem(theMenuItemPropToken.theItemToken.theMenuToken.theTokenMenu,
  2340.                                             theMenuItemPropToken.theItemToken.theTokenItem,
  2341.                                             theName);
  2342.                             theErr  = AECreateDesc(typeChar,
  2343.                                                                          (Ptr)&theName[1],
  2344.                                                                          theName[0],
  2345.                                                                          dataDesc);
  2346.                             break;
  2347.             
  2348.             case pItemNumber:
  2349.         
  2350.                             theErr  = AECreateDesc(typeShortInteger,
  2351.                                                                          (Ptr)&theMenuItemPropToken.theItemToken.theTokenItem,
  2352.                                                                          sizeof(theMenuItemPropToken.theItemToken.theTokenItem),
  2353.                                                                          dataDesc);
  2354.                             break;
  2355.                             
  2356.             case pDefaultType:
  2357.             case pBestType:
  2358.                             
  2359.                             PLstrcpy(theName, (**theMenuItemPropToken.theItemToken.theMenuToken.theTokenMenu).menuData);
  2360.                             
  2361.                             theErr  = MakeMenuItemObj(theName,
  2362.                                                                                 theMenuItemPropToken.theItemToken.theTokenItem,
  2363.                                                                                 dataDesc);
  2364.                             break;
  2365.                             
  2366.             case pClass:
  2367.                             
  2368.                             theErr  = MakeClassObj(cMenuItem, dataDesc);
  2369.                             break;
  2370.                             
  2371.             default: 
  2372.                             theErr = errAEEventNotHandled;
  2373.                             
  2374.         }
  2375.             
  2376.         return(theErr);
  2377.     } /* GetMenuItemProperty */
  2378.  
  2379. /** -----------------------------------------------------------------------
  2380.         Name:             HandleGetData
  2381.         Purpose:        Coerces theObj into a token which we understand and
  2382.                                 extracts the data requested in the token and puts it
  2383.                                 into dataDesc.
  2384.      -----------------------------------------------------------------------**/
  2385.      
  2386. typedef char chars[32001];
  2387. typedef chars **charsHandle;
  2388.  
  2389.  
  2390. pascal OSErr HandleGetData(AEDesc *theObj, DescType whatType, AEDesc *dataDesc)
  2391.   {
  2392. #pragma unused (whatType)
  2393.  
  2394.       OSErr           myErr;
  2395.         OSErr                        ignoreErr;
  2396.         AEDesc          newDesc;
  2397.         TextToken       theTextToken;
  2398.         Size            tokenSize;
  2399.         DPtr            theDoc;
  2400.         AEDesc          objTokenDesc;
  2401.         
  2402.         /*
  2403.             Resolve theObj into a token which we can use - 
  2404.                  get the property or data for that token
  2405.         */    
  2406.     
  2407.         myErr = AEResolve(theObj ,kAEIDoMinimum, &objTokenDesc);
  2408.         
  2409.         if (myErr == noErr)    
  2410.             switch (objTokenDesc.descriptorType){
  2411.             
  2412.                 case typeMyApplProp : myErr = GetApplicationProperty(&objTokenDesc, dataDesc);
  2413.                                                             break;
  2414.                                                             
  2415.                 case typeMyMenuProp : myErr = GetMenuProperty(&objTokenDesc, dataDesc);
  2416.                                                             break;
  2417.                 
  2418.                 case typeMyItemProp : myErr = GetMenuItemProperty(&objTokenDesc, dataDesc);
  2419.                                                             break;
  2420.                 
  2421.                 case typeMyTextProp : myErr = GetTextProperty(&objTokenDesc, dataDesc);
  2422.                                                             break;
  2423.                 
  2424.                 case typeMyWindowProp:myErr = GetWindowProperty(&objTokenDesc, dataDesc);
  2425.                                                             break;
  2426.                 
  2427.                 case typeMyText     :if (AECoerceDesc(&objTokenDesc, typeMyText, &newDesc) == noErr) 
  2428.                                                             {
  2429.                                                                 GetRawDataFromDescriptor(&newDesc,
  2430.                                                                                                                  (Ptr)&theTextToken,
  2431.                                                                                                                  sizeof(theTextToken),
  2432.                                                                                                                  &tokenSize);
  2433.                                                                 
  2434.                                                                 ignoreErr = AEDisposeDesc(&newDesc);
  2435.                                                                                                                  
  2436.                                                                 theDoc = DPtrFromWindowPtr(theTextToken.tokenWindow);
  2437.                                                                 
  2438.                                                                 myErr = BuildStyledTextDesc(theDoc->theText,
  2439.                                                                                                                         theTextToken.tokenOffset,
  2440.                                                                                                                         theTextToken.tokenLength,
  2441.                                                                                                                         dataDesc);
  2442.                                             
  2443.                                                             }
  2444.                                                          break;
  2445.                                                          
  2446.                 default : myErr = errAEWrongDataType;
  2447.             }
  2448.         return(myErr);
  2449.     }    /* HandleGetData */
  2450.  
  2451. /** -----------------------------------------------------------------------
  2452.         Name:             CheckSender
  2453.         Purpose:        Finds the Sender of the AppleEvent.
  2454.      -----------------------------------------------------------------------**/
  2455.      
  2456. pascal void CheckSender(const AppleEvent *theAppleEvent)
  2457.     {
  2458.         OSErr    myErr;
  2459.         TargetID sender;
  2460.         DescType returnedType;
  2461.         Size     actSize;
  2462.         
  2463.         myErr = AEGetAttributePtr(theAppleEvent,
  2464.                                                             keyAddressAttr,
  2465.                                                             typeTargetID,
  2466.                                                             &returnedType,
  2467.                                                             (Ptr)&sender,
  2468.                                                             sizeof(sender),
  2469.                                                             &actSize);
  2470.                                                             
  2471.         // DebugStr((Str255)sender.name.name);
  2472.     }
  2473.  
  2474. /** -----------------------------------------------------------------------
  2475.         Name:             DoGetData
  2476.         Purpose:        Handles the GetData AppleEvent.
  2477.      -----------------------------------------------------------------------**/
  2478.  
  2479. pascal OSErr DoGetData(const AppleEvent *theAppleEvent,
  2480.                                          AppleEvent *reply,
  2481.                                          long handlerRefCon)
  2482.     { 
  2483. #pragma unused (handlerRefCon)
  2484.  
  2485.         OSErr    myErr;
  2486.         OSErr    tempErr;
  2487.         AEDesc   myDirObj;
  2488.         AEDesc   myDataDesc;
  2489.         Size     actualSize;
  2490.         DescType returnedType;
  2491.         DescType reqType;
  2492.         
  2493.         myDataDesc.dataHandle = nil;
  2494.         myDirObj.dataHandle   = nil;
  2495.         
  2496.         /*
  2497.             CheckSender(theAppleEvent);
  2498.         */
  2499.         
  2500.         /*
  2501.             extract the direct object, which is the object whose data is to be returned
  2502.         */
  2503.         
  2504.         myErr  = AEGetParamDesc(theAppleEvent,
  2505.                                                         keyDirectObject,
  2506.                                                         typeWildCard,
  2507.                                                         &myDirObj);
  2508.             
  2509.         /*
  2510.             now the get the type of data wanted - optional
  2511.         */
  2512.         
  2513.         tempErr = AEGetParamPtr(theAppleEvent,
  2514.                                                         keyAERequestedType,
  2515.                                                         typeType,
  2516.                                                         &returnedType,
  2517.                                                         (Ptr)&reqType,
  2518.                                                         sizeof(reqType),
  2519.                                                         &actualSize);
  2520.         if (tempErr!=noErr) 
  2521.             reqType = typeChar;
  2522.             
  2523.         if (myErr == noErr) 
  2524.             myErr = GotRequiredParams(theAppleEvent);
  2525.         
  2526.         /* get the data */
  2527.         if (myErr == noErr) 
  2528.             myErr = HandleGetData(&myDirObj, reqType, &myDataDesc);
  2529.             
  2530.         /* if they wanted a reply, attach it now */
  2531.         if (myErr==noErr) 
  2532.             if (reply->descriptorType != typeNull) 
  2533.                 myErr = AEPutParamDesc(reply, keyDirectObject, &myDataDesc);
  2534.                 
  2535.     if (myDataDesc.dataHandle)
  2536.           tempErr = AEDisposeDesc(&myDataDesc);
  2537.  
  2538.     if (myDirObj.dataHandle)
  2539.           tempErr = AEDisposeDesc(&myDirObj);
  2540.             
  2541.         return(myErr);
  2542.     }    /* DoGetData */
  2543.  
  2544.  
  2545. /** -----------------------------------------------------------------------
  2546.         Name:             DoGetDataSize
  2547.         Purpose:        Handles the GetDataSize AppleEvent.
  2548.      -----------------------------------------------------------------------**/
  2549.  
  2550. pascal OSErr DoGetDataSize(const AppleEvent *theAppleEvent,
  2551.                                                         AppleEvent *reply,
  2552.                                                                  long       handlerRefCon)
  2553.   { 
  2554. #pragma unused (handlerRefCon)
  2555.     
  2556.         OSErr     myErr;
  2557.         OSErr     tempErr;
  2558.         AEDesc    myDirObj;
  2559.         AEDesc    myDataDesc;
  2560.         Size      actualSize;
  2561.         DescType  returnedType;
  2562.         DescType  reqType;
  2563.         long      dataSize;
  2564.         
  2565.         myDataDesc.dataHandle = nil;
  2566.         myDirObj.dataHandle   = nil;
  2567.         
  2568.         /* pick up the direct object, which is the object whose data is to be sized */
  2569.         
  2570.         myErr  = AEGetParamDesc(theAppleEvent,
  2571.                                                         keyDirectObject,
  2572.                                                         typeWildCard,
  2573.                                                         &myDirObj);
  2574.             
  2575.         /* now the get the type wanted - optional*/
  2576.         
  2577.         tempErr = AEGetParamPtr(theAppleEvent,
  2578.                                                         keyAERequestedType,
  2579.                                                         typeType,
  2580.                                                         &returnedType,
  2581.                                                         (Ptr)&reqType,
  2582.                                                         sizeof(reqType),
  2583.                                                         &actualSize);
  2584.         
  2585.         if (tempErr!=noErr) 
  2586.             reqType = typeChar;
  2587.             
  2588.         if (myErr == noErr) 
  2589.             myErr = GotRequiredParams(theAppleEvent);
  2590.         
  2591.         /* get the data */
  2592.         if (myErr == noErr) 
  2593.             myErr = HandleGetData(&myDirObj, reqType, &myDataDesc);
  2594.             
  2595.         /* evaluate size of data and discard, create desc for size */
  2596.         if (myErr == noErr) 
  2597.             if (myDataDesc.dataHandle) 
  2598.                 {
  2599.                     dataSize = GetHandleSize((Handle)myDataDesc.dataHandle);
  2600.                     DisposHandle((Handle)myDataDesc.dataHandle);
  2601.                     myErr  = AECreateDesc(typeLongInteger,
  2602.                                                                 (Ptr)&dataSize,
  2603.                                                                 sizeof(dataSize),
  2604.                                                                 &myDataDesc);
  2605.                 }
  2606.             
  2607.             
  2608.         /* if they wanted a reply, attach it now */
  2609.         
  2610.         if (myErr==noErr) 
  2611.             if (reply->descriptorType != typeNull) 
  2612.                 myErr = AEPutParamDesc(reply, keyDirectObject, &myDataDesc);
  2613.                 
  2614.         /* discard our copy */
  2615.         
  2616.         if (myDataDesc.dataHandle) 
  2617.             tempErr = AEDisposeDesc(&myDataDesc);
  2618.                 
  2619.         if (myDirObj.dataHandle) 
  2620.             tempErr = AEDisposeDesc(&myDirObj);
  2621.                 
  2622.         return(myErr);
  2623.     }    /* DoGetDataSize */
  2624.  
  2625. /** -----------------------------------------------------------------------
  2626.         Name:             DoNewElement
  2627.         Purpose:        Handles the NewElement AppleEvent. Only Creates windows for
  2628.                     now.
  2629.      -----------------------------------------------------------------------**/
  2630.  
  2631. pascal OSErr DoNewElement(const AppleEvent *theAppleEvent,
  2632.                                                 AppleEvent *reply, 
  2633.                                                 long       handlerRefCon)
  2634. {
  2635. #pragma unused (handlerRefCon)
  2636.  
  2637.     OSErr       myErr;
  2638.     OSErr       ignoreErr;
  2639.     DescType      returnedType;
  2640.     DescType      newElemClass;
  2641.     Size        actSize;
  2642.     AEDesc        wndwObjSpec;
  2643.     DPtr        theDoc;
  2644.     
  2645.     wndwObjSpec.dataHandle = nil;
  2646.         
  2647.     myErr = AEGetParamPtr(theAppleEvent,
  2648.                                                 keyAEObjectClass,
  2649.                                                 typeType,
  2650.                                                 &returnedType,
  2651.                                                 (Ptr)&newElemClass,
  2652.                                                 sizeof(newElemClass),
  2653.                                                 &actSize);
  2654.             
  2655.   /* check for missing required parameters */
  2656.     
  2657.   if (myErr == noErr) 
  2658.         myErr = GotRequiredParams(theAppleEvent);
  2659.   
  2660.   /* got all required params */
  2661.   
  2662.   /* let's make sure container is the null desc */
  2663.   /* and they want a window */
  2664.     
  2665.   if (newElemClass != cWindow) 
  2666.     myErr = errAEWrongDataType;
  2667.   
  2668.   /* let's create a new window */
  2669.     
  2670.     if (myErr == noErr) 
  2671.         theDoc = NewDocument(false);
  2672.   
  2673.     if (myErr==noErr)
  2674.         if (theDoc == nil) 
  2675.             myErr = -1700;
  2676.         else
  2677.             {
  2678.                 ShowWindow(theDoc->theWindow);
  2679.                 theDoc->dirty = false;
  2680.             
  2681.                 myErr = MakeWindowObj(theDoc->theWindow, &wndwObjSpec);
  2682.             }
  2683.       
  2684.     if (myErr == noErr) 
  2685.         if (reply->descriptorType != typeNull) 
  2686.              myErr = AEPutParamDesc(reply,
  2687.                                                             keyDirectObject,
  2688.                                                             &wndwObjSpec);
  2689.             
  2690.     if (wndwObjSpec.dataHandle) 
  2691.         ignoreErr = AEDisposeDesc(&wndwObjSpec);
  2692.         
  2693.   return(myErr);
  2694. }    /* DoNewElement */
  2695.  
  2696. /** -----------------------------------------------------------------------
  2697.         Name:             DoIsThereA
  2698.         Purpose:        Handles the IsThereA AppleEvent.
  2699.      -----------------------------------------------------------------------**/
  2700.  
  2701. pascal OSErr DoIsThereA(const AppleEvent *theAppleEvent,
  2702.                                             AppleEvent       *reply, 
  2703.                                             long             handlerRefCon)
  2704.                                             
  2705. /*
  2706.     Support check of Windows at first
  2707.     
  2708.     What we do :
  2709.         Get Direct Object
  2710.         Check have all required params
  2711.         Coerce into things we support
  2712.         if we get something back
  2713.             check to see it exists and set reply
  2714.         clean up
  2715.         return
  2716. */
  2717.  
  2718.  {
  2719. #pragma unused (handlerRefCon)
  2720.  
  2721.         OSErr         myErr;
  2722.         OSErr         ignoreErr;
  2723.         AEDesc        myDirObject;
  2724.         AEDesc        windDesc;
  2725.         AEDesc        dataDesc;
  2726.         WindowToken   theWindowToken;
  2727.         Size          tokenSize;
  2728.         Boolean       exists;
  2729.  
  2730.         myDirObject.dataHandle = nil;
  2731.         windDesc.dataHandle    = nil;
  2732.         dataDesc.dataHandle    = nil;
  2733.                 
  2734.         myErr = AEGetParamDesc(theAppleEvent,
  2735.                                                      keyDirectObject,
  2736.                                                      typeWildCard,
  2737.                                                      &myDirObject);
  2738.                         
  2739.         /* check for missing required parameters */
  2740.         
  2741.         if (myErr == noErr) 
  2742.             myErr = GotRequiredParams(theAppleEvent);
  2743.         
  2744.         /* got all required params */
  2745.         
  2746.         /* let's make sure they want to check for a window */
  2747.             
  2748.         exists = false;
  2749.         
  2750.         if (myErr == noErr) 
  2751.             if (AECoerceDesc(&myDirObject, typeMyWndw, &windDesc)==noErr) 
  2752.                 if (windDesc.descriptorType!=typeNull) 
  2753.                     {
  2754.                         GetRawDataFromDescriptor(&windDesc,
  2755.                                                                          (Ptr)&theWindowToken,
  2756.                                                                          sizeof(theWindowToken),
  2757.                                                                          &tokenSize);
  2758.                                                                          
  2759.                         exists = (theWindowToken != nil);    
  2760.                     }
  2761.                     
  2762.         if (myErr == noErr) 
  2763.             myErr = AECreateDesc(typeBoolean,
  2764.                                                      (Ptr)&exists,
  2765.                                                      sizeof(exists),
  2766.                                                      &dataDesc);
  2767.     
  2768.             
  2769.         /* 
  2770.             if they wanted a reply, which they surely must, 
  2771.             attach the result to it…
  2772.         */
  2773.             
  2774.         if (myErr == noErr)
  2775.             if (reply->descriptorType != typeNull) 
  2776.                  myErr = AEPutParamDesc(reply,
  2777.                                                                 keyDirectObject,
  2778.                                                                 &dataDesc);
  2779.                 
  2780.         if (dataDesc.dataHandle) 
  2781.             ignoreErr = AEDisposeDesc(&dataDesc);
  2782.             
  2783.         if (myDirObject.dataHandle) 
  2784.             ignoreErr = AEDisposeDesc(&myDirObject);
  2785.             
  2786.         if (windDesc.dataHandle) 
  2787.             ignoreErr = AEDisposeDesc(&windDesc);
  2788.             
  2789.         return(myErr);
  2790.     }    /* DoIsThereA */
  2791.  
  2792. /** -----------------------------------------------------------------------
  2793.         Name:             DoCloseWindow
  2794.         Purpose:        Handles the Close AppleEvent.
  2795.      -----------------------------------------------------------------------**/
  2796.  
  2797. pascal OSErr DoCloseWindow(const AppleEvent *theAppleEvent,
  2798.                                                     AppleEvent       *reply,
  2799.                                                     long             handlerRefCon)
  2800.     { 
  2801. #pragma unused (reply, handlerRefCon)
  2802.  
  2803.         OSErr         myErr;
  2804.         OSErr         tempErr;
  2805.         OSErr                 ignoreErr;
  2806.         AEDesc        myDirObj;
  2807.         AEDesc        newDesc;
  2808.         WindowToken   theWindowToken;
  2809.         Size          tokenSize;
  2810.         DescType      saveOpt;
  2811.         Size          actSize;
  2812.         DescType      returnedType;
  2813.         DPtr          myDPtr;
  2814.  
  2815.         myDirObj.dataHandle = nil;
  2816.         
  2817.         /* pick up the direct object, which is the object (window) to close */
  2818.         
  2819.         myErr = AEGetParamDesc(theAppleEvent,
  2820.                                                      keyDirectObject,
  2821.                                                      typeWildCard,
  2822.                                                      &myDirObj);
  2823.                     
  2824.         /* pick up optional save param, if any */
  2825.         
  2826.         saveOpt = kAEAsk; /* the default */
  2827.         
  2828.         tempErr = AEGetParamPtr(theAppleEvent,
  2829.                                                         keyAESaveOptions,
  2830.                                                         typeEnumerated,
  2831.                                                         &returnedType,
  2832.                                                         (Ptr)&saveOpt,
  2833.                                                         sizeof(saveOpt),
  2834.                                                         &actSize);
  2835.                                                          
  2836.         if (myErr == noErr)
  2837.             myErr = GotRequiredParams(theAppleEvent);
  2838.             
  2839.         /* get the window to close as a window ptr */
  2840.         if (myErr == noErr) 
  2841.             if (AECoerceDesc(&myDirObj, typeMyWndw, &newDesc)==noErr) 
  2842.                 if (newDesc.descriptorType!=typeNull) 
  2843.                     {
  2844.                         GetRawDataFromDescriptor(&newDesc,
  2845.                                                                          (Ptr)&theWindowToken,
  2846.                                                                          sizeof(theWindowToken),
  2847.                                                                          &tokenSize);
  2848.                                                                          
  2849.                         ignoreErr = AEDisposeDesc(&newDesc);
  2850.                         
  2851.                         if (theWindowToken) 
  2852.                             {
  2853.                                 myErr=AESetInteractionAllowed(kAEInteractWithAll); /* Should do this in prefs */
  2854.                                 
  2855.                                 /*
  2856.                                     We do some of the close checks here to avoid
  2857.                                     calling AEInteractWithUser
  2858.                                 */
  2859.                                 myDPtr = DPtrFromWindowPtr(theWindowToken);
  2860.                                 if ((myDPtr->dirty) || (myDPtr->everSaved == false)) 
  2861.                                     if (saveOpt != kAENo) /* Don't flip layers if force no ask */
  2862.                                         myErr = AEInteractWithUser(kAEDefaultTimeout, nil, nil);
  2863.                                     
  2864.                                 if (myErr==noErr) 
  2865.                                     myErr = DoClose(theWindowToken, true, saveOpt);
  2866.                             }
  2867.                         else
  2868.                             myErr =  errAEIllegalIndex;
  2869.                     }
  2870.                         
  2871.         if (myDirObj.dataHandle) 
  2872.             tempErr = AEDisposeDesc(&myDirObj);
  2873.                 
  2874.         return(myErr);
  2875.     }    /* DoCloseWindow */
  2876.  
  2877. /** -----------------------------------------------------------------------
  2878.         Name:             IndexFromWindowPtr
  2879.         Purpose:        calculates index of WindowPtr.
  2880.                     1 == frontmost window
  2881.                                 0 == no window
  2882.                                 n == n-1 behind first window
  2883.      -----------------------------------------------------------------------**/
  2884.  
  2885. pascal short IndexFromWindowPtr(WindowPtr theWindowPtr)
  2886.  {
  2887.          short     index;
  2888.         WindowPtr checkWin;
  2889.         
  2890.         index = 0;
  2891.         checkWin = (WindowPtr)LMGetWindowList();
  2892.          
  2893.         //    iterate through windows - we use WindowList to see all windows visible or not
  2894.         
  2895.         while (checkWin)
  2896.             {
  2897.                 index++;
  2898.                 
  2899.                 if (checkWin==theWindowPtr)
  2900.                     return(index);
  2901.                     
  2902.               checkWin = (WindowPtr)((WindowPeek)checkWin)->nextWindow;
  2903.             }
  2904.             
  2905.         return(0);
  2906.  }
  2907.  
  2908. /** -----------------------------------------------------------------------
  2909.         Name:             MoveWindowRelative
  2910.         Purpose:        Moves one window relative to another.
  2911.      -----------------------------------------------------------------------**/
  2912.  
  2913. pascal OSErr MoveWindowRelative(WindowToken theWindowToken,
  2914.                                 WindowToken theRelWindowToken,
  2915.                                                               DescType    theRelPosn)
  2916.     {
  2917.         short win1Index;
  2918.         short win2Index;
  2919.         OSErr myErr = noErr;
  2920.         
  2921.         win1Index = IndexFromWindowPtr(theWindowToken);
  2922.         win2Index = IndexFromWindowPtr(theRelWindowToken);
  2923.         
  2924.         if (theRelPosn==kAEBefore)
  2925.             if (win2Index==1)
  2926.                 {
  2927.                     SelectWindow(theWindowToken); // special case - make frontmost window
  2928.                     return(myErr);
  2929.                 }
  2930.             else
  2931.                 { // in front of 3 == behind 2 so…
  2932.                     win2Index--;
  2933.                 }
  2934.         
  2935.         if (win2Index!=win1Index+1)
  2936.             {
  2937.                 SendBehind(theWindowToken,theRelWindowToken);
  2938.                 
  2939.                 if (win1Index > win2Index + 1)
  2940.                      // Fix up visRgn as per Inside Mac I-286.
  2941.                     {    
  2942. //                        PaintOne((WindowPeek)theWindowToken,
  2943. //                                         ((WindowPeek)theWindowToken)->strucRgn);
  2944. //                        CalcVis((WindowPeek)theWindowToken);
  2945.                     }
  2946.             }
  2947.         return(myErr);
  2948.     }
  2949.  
  2950. /** -----------------------------------------------------------------------
  2951.         Name:             DoMoveWindow
  2952.         Purpose:        Handles the Move AppleEvent for windows.
  2953.      -----------------------------------------------------------------------**/
  2954.  
  2955. pascal OSErr DoMoveWindow(const AppleEvent *theAppleEvent,
  2956.                                                    AppleEvent       *reply,
  2957.                                                    long             handlerRefCon)
  2958.     { 
  2959. #pragma unused (reply, handlerRefCon)
  2960.  
  2961.         OSErr         myErr;
  2962.         OSErr                 ignoreErr;
  2963.         AEDesc        whereToPutIt;
  2964.         AEDesc        theLocationRec;
  2965.         DescType      theRelPosn;
  2966.         WindowToken   theWindowToken;
  2967.         WindowToken   theRefWindowToken;
  2968.         Size          actSize;
  2969.         DescType      returnedType;
  2970.  
  2971.         whereToPutIt.dataHandle   = nil;
  2972.         theLocationRec.dataHandle = nil;
  2973.         
  2974.         /* pick up the direct object, which is the object (window) to move */
  2975.         
  2976.         myErr = AEGetParamPtr(theAppleEvent,
  2977.                                                     keyDirectObject,
  2978.                                                     typeMyWndw,
  2979.                                                     &returnedType,
  2980.                                                     (Ptr)&theWindowToken,
  2981.                                                     sizeof(theWindowToken),
  2982.                                                     &actSize);
  2983.                     
  2984.         /* pick up where to information */
  2985.         
  2986.         if (myErr==noErr)
  2987.             myErr = AEGetParamDesc(theAppleEvent,
  2988.                                                          keyAEInsertHere,
  2989.                                                          typeInsertionLoc,
  2990.                                                          &whereToPutIt);
  2991.                                                          
  2992.         if (myErr==noErr)
  2993.             {
  2994.                 myErr = AECoerceDesc(&whereToPutIt, typeAERecord, &theLocationRec);
  2995.                                 
  2996.                 if (myErr==noErr)
  2997.                     myErr = AEGetKeyPtr(&theLocationRec,
  2998.                                                             keyAEObject,
  2999.                                                             typeMyWndw,
  3000.                                                             &returnedType,
  3001.                                                             (Ptr)&theRefWindowToken,
  3002.                                                             sizeof(theRefWindowToken),
  3003.                                                             &actSize);
  3004.                 if (myErr==noErr)
  3005.                     myErr = AEGetKeyPtr(&theLocationRec,
  3006.                                                             keyAEPosition,
  3007.                                                             typeEnumerated,
  3008.                                                             &returnedType,
  3009.                                                             (Ptr)&theRelPosn,
  3010.                                                             sizeof(theRelPosn),
  3011.                                                             &actSize);
  3012.                                                             
  3013.                 if (theLocationRec.dataHandle)
  3014.                     ignoreErr = AEDisposeDesc(&theLocationRec);
  3015.             }
  3016.                                          
  3017.         if (myErr == noErr)
  3018.             myErr = GotRequiredParams(theAppleEvent);
  3019.  
  3020.         if (theRelPosn==kAEBefore ||
  3021.             theRelPosn==kAEAfter)
  3022.             MoveWindowRelative(theWindowToken, theRefWindowToken, theRelPosn);
  3023.         else
  3024.             myErr = errAEEventNotHandled;
  3025.             
  3026.         if (whereToPutIt.dataHandle)
  3027.             ignoreErr = AEDisposeDesc(&whereToPutIt);
  3028.                     
  3029.         // Now place one window relative to the other
  3030.         
  3031.         return(myErr);
  3032.     }    /* DoMoveWindow */
  3033.  
  3034.  
  3035. /** -----------------------------------------------------------------------
  3036.         Name:             DoSaveWindow
  3037.         Purpose:        Handles the Save AppleEvent.
  3038.      -----------------------------------------------------------------------**/
  3039.  
  3040. pascal OSErr DoSaveWindow(const AppleEvent *theAppleEvent,
  3041.                                                  AppleEvent       *reply,
  3042.                                                  long             handlerRefCon)
  3043.     { 
  3044. #pragma unused (reply, handlerRefCon)
  3045.     
  3046.         OSErr         myErr;
  3047.         OSErr         tempErr;
  3048.         OSErr         ignoreErr;
  3049.         AEDesc        myDirObj;
  3050.         AEDesc        newDesc;
  3051.         WindowToken   theWindowToken;
  3052.         Size          tokenSize;
  3053.         Size          actSize;
  3054.         DescType      returnedType;
  3055.         DPtr          theDoc;
  3056.         FSSpec        destFSSpec;
  3057.         
  3058.         myDirObj.dataHandle = nil;
  3059.         
  3060.         /* pick up the direct object, which is the window to save */
  3061.         
  3062.         myErr = AEGetParamDesc(theAppleEvent,
  3063.                                                      keyDirectObject,
  3064.                                                      typeWildCard,
  3065.                                                      &myDirObj);
  3066.                                                      
  3067.         /* pick up optional destination param, if any */
  3068.     
  3069.         tempErr = AEGetParamPtr(theAppleEvent,
  3070.                                                         keyAEDestination,
  3071.                                                       typeFSS,
  3072.                                                         &returnedType,
  3073.                                                         (Ptr)&destFSSpec,
  3074.                                                         sizeof(destFSSpec),
  3075.                                                         &actSize);
  3076.     
  3077.         if (myErr == noErr) 
  3078.             myErr = GotRequiredParams(theAppleEvent);
  3079.             
  3080.         /* get the data */
  3081.     
  3082.         myErr = AECoerceDesc(&myDirObj, typeMyWndw, &newDesc);
  3083.         
  3084.         if (myErr == noErr)
  3085.             if (newDesc.descriptorType!=typeNull) 
  3086.                 {
  3087.                     GetRawDataFromDescriptor(&newDesc,
  3088.                                                                      (Ptr)&theWindowToken,
  3089.                                                                      sizeof(theWindowToken),
  3090.                                                                      &tokenSize);
  3091.                                                                      
  3092.                     ignoreErr = AEDisposeDesc(&newDesc);
  3093.                                                                      
  3094.                     if (theWindowToken) 
  3095.                         {                            
  3096.                             theDoc = DPtrFromWindowPtr(theWindowToken);
  3097.                             
  3098.                             if (theDoc->everSaved == false) 
  3099.                                 if (tempErr != noErr) 
  3100.                                      /* We had no supplied destination and no default either */
  3101.                                     myErr = kAEGenericErr;
  3102.                             
  3103.                             if (myErr==noErr)
  3104.                                 if (tempErr==noErr)    /* we were told where */
  3105.                                     myErr = DoSave(theDoc, destFSSpec); 
  3106.                                 else
  3107.                                     myErr = SaveUsingTemp(theDoc);
  3108.                         }
  3109.                     else
  3110.                         myErr =  errAEIllegalIndex;
  3111.                 }
  3112.                 
  3113.         if (myDirObj.dataHandle) 
  3114.             tempErr = AEDisposeDesc(&myDirObj);
  3115.     
  3116.         return(myErr);
  3117.                     
  3118.     }    /* DoSaveWindow */
  3119.  
  3120. /** -----------------------------------------------------------------------
  3121.         Name:             DoRevertWindow
  3122.         Purpose:        Handles the Revert AppleEvent.
  3123.      -----------------------------------------------------------------------**/
  3124.  
  3125. pascal OSErr DoRevertWindow(const AppleEvent *theAppleEvent,
  3126.                                                      AppleEvent       *reply,
  3127.                                                      long             handlerRefCon)
  3128. { 
  3129. #pragma unused (reply, handlerRefCon)
  3130.  
  3131.     OSErr          myErr;
  3132.     OSErr          ignoreErr;
  3133.     AEDesc         myDirObj;
  3134.     AEDesc         newDesc;
  3135.     WindowToken    theWindowToken;
  3136.     Size           tokenSize;
  3137.     DPtr           theDoc;
  3138.     
  3139.     myDirObj.dataHandle = nil;
  3140.     
  3141.   /* pick up the direct object, which is the window to save */
  3142.     
  3143.   myErr = AEGetParamDesc(theAppleEvent,
  3144.                                                  keyDirectObject,
  3145.                                                  typeWildCard,
  3146.                                                  &myDirObj);
  3147.  
  3148.     if (myErr == noErr)
  3149.       myErr = GotRequiredParams(theAppleEvent);
  3150.         
  3151.   /* get the window to revert from the direct object */
  3152.     
  3153.     myErr = AECoerceDesc(&myDirObj, typeMyWndw, &newDesc);
  3154.     
  3155.   if (myErr == noErr) 
  3156.         if (newDesc.descriptorType!=typeNull) 
  3157.             {
  3158.                 GetRawDataFromDescriptor(&newDesc,
  3159.                                                                  (Ptr)&theWindowToken,
  3160.                                                                  sizeof(theWindowToken),
  3161.                                                                  &tokenSize);
  3162.                                                                  
  3163.                 ignoreErr = AEDisposeDesc(&newDesc);
  3164.                                                                  
  3165.                 if (theWindowToken) 
  3166.                     {    
  3167.                         theDoc = DPtrFromWindowPtr(theWindowToken);
  3168.                         
  3169.                         HidePen();
  3170.                         TESetSelect(0, (*(theDoc->theText))->teLength, theDoc->theText);
  3171.                         ShowPen();
  3172.                         TEDelete(theDoc->theText);
  3173.         
  3174.                         if (theDoc->everSaved) 
  3175.                             {
  3176.                                 myErr = GetFileContents(theDoc->theFSSpec, theDoc);
  3177.                                 if (myErr == noErr) 
  3178.                                     {
  3179.                                         ResizeWindow(theDoc);
  3180.                                         theDoc->dirty = false;
  3181.                                     }
  3182.                             }
  3183.         
  3184.                         ShowWindow(theDoc->theWindow); /* <<< Visible already??? */
  3185.                         DoUpdate(theDoc);
  3186.                     }
  3187.                 else
  3188.                     myErr =  errAEIllegalIndex;
  3189.             }
  3190.                 
  3191.     if (myDirObj.dataHandle) 
  3192.         ignoreErr = AEDisposeDesc(&myDirObj);
  3193.         
  3194.   return(myErr);
  3195. }    /* DoRevertWindow */
  3196.  
  3197. /**-----------------------------------------------------------------------
  3198.         Name:             DoPrintDocuments
  3199.         Purpose:        Print a list of documents (or windows).
  3200. -----------------------------------------------------------------------**/
  3201. pascal OSErr DoPrintDocuments(const AppleEvent *message,
  3202.                               AppleEvent       *reply,
  3203.                                                             long refcon)
  3204. {
  3205. #pragma unused (reply, refcon)
  3206.         long          index;
  3207.         long          itemsInList;
  3208.         AEKeyword     keywd;
  3209.         OSErr         err;
  3210.         AEDescList    docList;
  3211.         Size          actSize;
  3212.         DescType      typeCode;
  3213.         FSSpec        theFSSpec;
  3214.         WindowToken   theWindowToken;
  3215.         OSErr         forgetErr;
  3216.         Boolean       talkToUser;
  3217.             
  3218.         err = AEGetParamDesc(message,
  3219.                                                  keyDirectObject,
  3220.                                                  typeAEList,
  3221.                                                  &docList);
  3222.                                                  
  3223.         err = AECountItems(&docList, &itemsInList);
  3224.             
  3225.         for (index = 1; index<=itemsInList; index++)
  3226.             if (err == noErr) 
  3227.                 {
  3228.                     forgetErr = AEGetNthPtr( &docList, index, typeFSS, &keywd,
  3229.                                                                      &typeCode, (Ptr)&theFSSpec, sizeof(theFSSpec), &actSize);
  3230.                                                                         
  3231.                     if (forgetErr == noErr) 
  3232.                         {
  3233.                             if (err == noErr) 
  3234.                                 err = IssueAEOpenDoc(theFSSpec);
  3235.                                 
  3236.                             if (err == noErr) 
  3237.                                 IssuePrintWindow(FrontWindow());
  3238.                                 
  3239.                             if (err == noErr) 
  3240.                                 IssueCloseCommand(FrontWindow());
  3241.                         }
  3242.                     else
  3243.                         { /* wasn't a file - was it a window ? */
  3244.                             err = AEGetNthPtr(&docList,
  3245.                                               index,
  3246.                                               typeMyWndw,
  3247.                                               &keywd,
  3248.                                                                 &typeCode,
  3249.                                                                 (Ptr)&theWindowToken,
  3250.                                                                 sizeof(WindowToken),
  3251.                                                                 &actSize);
  3252.                                                                     
  3253.                             talkToUser = (AEInteractWithUser(kAEDefaultTimeout, nil, nil) == noErr);
  3254.                             
  3255.                             if (err == noErr) 
  3256.                                 PrintWindow(DPtrFromWindowPtr(theWindowToken), talkToUser);
  3257.                         }
  3258.                 }
  3259.         
  3260.         if (docList.dataHandle)
  3261.             forgetErr = AEDisposeDesc(&docList);
  3262.             
  3263.         return(err);
  3264.     } /* DoPrintDocuments */
  3265.  
  3266.  
  3267.  
  3268. pascal OSErr MyCountProc(    DescType desiredType,
  3269.                                                     DescType containerClass,
  3270.                                                     const AEDesc *container,
  3271.                                                     long *result);
  3272.                                             
  3273. /** -----------------------------------------------------------------------
  3274.         Name:       HandleNumberOfElements
  3275.         Purpose:        Handles the Number Of Elements AppleEvent.
  3276.      -----------------------------------------------------------------------**/
  3277.  
  3278. pascal OSErr HandleNumberOfElements(const AppleEvent *theAppleEvent,
  3279.                                                                     AppleEvent *reply,
  3280.                                                                     long       handlerRefCon)
  3281.   {
  3282. #pragma unused (handlerRefCon)
  3283.  
  3284.       OSErr    myErr;
  3285.       OSErr    forgetErr;
  3286.         AEDesc   myDirObj;
  3287.         DescType myClass;
  3288.         long     myCount;
  3289.         DescType returnedType;
  3290.         Size     actSize;
  3291.         
  3292.         myErr                 = errAEEventNotHandled;
  3293.         myDirObj.dataHandle = nil;
  3294.         
  3295.         /* pick up direct object, which is the container in which things are to be counted */
  3296.         
  3297.         myErr = AEGetParamDesc(theAppleEvent,
  3298.                                                      keyDirectObject,
  3299.                                                      typeWildCard,
  3300.                                                      &myDirObj);
  3301.             
  3302.         /* now the class of objects to be counted */
  3303.         
  3304.         myErr = AEGetParamPtr( theAppleEvent,
  3305.                                                      keyAEObjectClass,
  3306.                                                      typeType,
  3307.                                                      &returnedType,
  3308.                                                      (Ptr)&myClass,
  3309.                                                      sizeof(myClass),
  3310.                                                      &actSize);
  3311.             
  3312.         /* missing any parameters? */
  3313.         
  3314.         myErr = GotRequiredParams(theAppleEvent);
  3315.         
  3316.         /* now count */
  3317.     
  3318.         if (myErr == noErr) 
  3319.             myErr = MyCountProc(myClass,myDirObj.descriptorType, &myDirObj,&myCount);
  3320.         
  3321.         /* add result to reply */
  3322.     
  3323.         if (myErr == noErr) 
  3324.             if (reply->descriptorType != typeNull) 
  3325.                  myErr  = AEPutParamPtr(reply,
  3326.                                                                 keyDirectObject,
  3327.                                                                 typeLongInteger,
  3328.                                                                 (Ptr)&myCount,
  3329.                                                                 sizeof(myCount));
  3330.         if (myErr == noErr)       
  3331.             forgetErr  = AEDisposeDesc(&myDirObj);
  3332.         
  3333.         return(myErr);
  3334.         
  3335.     }    /* HandleNumberOfElements */
  3336.  
  3337. /** -----------------------------------------------------------------------
  3338.         Name:             HandleShowSelection
  3339.         Purpose:        Handles the Make Selection Visible AppleEvent.
  3340.      -----------------------------------------------------------------------**/
  3341.  
  3342. pascal OSErr HandleShowSelection(const AppleEvent *theAppleEvent,
  3343.                                                              AppleEvent       *reply,
  3344.                                                              long             handlerRefCon)
  3345.   {
  3346. #pragma unused (reply,handlerRefCon)
  3347.     
  3348.         OSErr       myErr;
  3349.         OSErr       ignoreErr;
  3350.         AEDesc      myDirObj;
  3351.         AEDesc      newDesc;
  3352.         AEDesc      tokenDesc;
  3353.         Size        actSize;
  3354.         WindowToken theWindowToken;
  3355.         DPtr        theDocument;
  3356.         TEHandle    theHTE;
  3357.         
  3358.         myErr      = errAEEventNotHandled;
  3359.         myDirObj.dataHandle  = nil;
  3360.         tokenDesc.dataHandle = nil;
  3361.         
  3362.         //    pick up direct object, i.e. the window in which to show the selection
  3363.             
  3364.         myErr  = AEGetParamDesc(theAppleEvent,
  3365.                                                         keyDirectObject,
  3366.                                                         typeWildCard,
  3367.                                                         &myDirObj);
  3368.                 
  3369.         //    missing any parameters?
  3370.         
  3371.         myErr = GotRequiredParams(theAppleEvent);
  3372.         
  3373.         //    convert object to WindowToken which we understand
  3374.  
  3375.         myErr = AEResolve(&myDirObj, kAEIDoMinimum, &tokenDesc);
  3376.         
  3377.         if (myErr == noErr)
  3378.             if (tokenDesc.descriptorType==typeMyWndw)
  3379.                 {
  3380.                     if (AECoerceDesc(&myDirObj, typeMyWndw, &newDesc) == noErr) 
  3381.                         {
  3382.                             GetRawDataFromDescriptor(&newDesc,
  3383.                                                                              (Ptr)&theWindowToken,
  3384.                                                                              sizeof(theWindowToken),
  3385.                                                                              &actSize);
  3386.         
  3387.                             ignoreErr = AEDisposeDesc(&newDesc);
  3388.                             
  3389.                             if (myErr==noErr) 
  3390.                                 if (theWindowToken)                                                          
  3391.                                     ShowSelect(DPtrFromWindowPtr(theWindowToken));
  3392.                                 else
  3393.                                     myErr = errAEIllegalIndex;
  3394.                         }
  3395.                 }
  3396.             else
  3397.                 if (tokenDesc.descriptorType==typeMyText)
  3398.                     {
  3399.                         myErr = SetSelectionOfAppleEventObject(keyDirectObject,
  3400.                                                                                           theAppleEvent,
  3401.                                                                                            &theDocument,
  3402.                                                                                           &theHTE);
  3403.                         if (theDocument)
  3404.                           ShowSelect(theDocument);
  3405.                         else
  3406.                             myErr = errAEIllegalIndex;
  3407.                     }
  3408.                 else
  3409.                     myErr = errAEEventNotHandled;
  3410.                     
  3411.         if (myDirObj.dataHandle)
  3412.             ignoreErr = AEDisposeDesc(&myDirObj);
  3413.         
  3414.         if (tokenDesc.dataHandle)
  3415.             ignoreErr = AEDisposeDesc(&tokenDesc);
  3416.             
  3417.         return(myErr);
  3418.         
  3419.     }    /* HandleShowSelection */
  3420.  
  3421. pascal OSErr HandleStartRecording(const AppleEvent *theAppleEvent,
  3422.                                                               AppleEvent *reply,
  3423.                                                               long       handlerRefCon)        
  3424.     {
  3425. #pragma unused (reply,handlerRefCon)
  3426.  
  3427.         OSErr myErr;
  3428.  
  3429.       gBigBrother++;
  3430.     
  3431.         myErr = GotRequiredParams(theAppleEvent);
  3432.  
  3433.         return(myErr);
  3434.         
  3435.     }    /* HandleStartRecording */
  3436.  
  3437. pascal OSErr HandleStopRecording(const AppleEvent *theAppleEvent,
  3438.                                                              AppleEvent *reply,
  3439.                                                                  long handlerRefCon)        
  3440.     {
  3441. #pragma unused (theAppleEvent,reply,handlerRefCon)
  3442.     
  3443.         gBigBrother--;
  3444.         return(noErr);
  3445.     }    /* HandleStopRecording */
  3446.  
  3447.  
  3448. #pragma segment AECommandIssuers
  3449.  
  3450. /*******************************************************************************/
  3451. /* 
  3452.         Start of section involved in building and sending AppleEvent Objects as/with
  3453.         commands
  3454.  */
  3455.  
  3456. /*
  3457.     Make an AEDesc that describes the selection in the window and text edit
  3458.     record supplied
  3459. */
  3460.  
  3461. pascal OSErr MakeWindowObj(WindowPtr theWindow,
  3462.                                                    AEDesc    *dMyDoc)
  3463.     {
  3464.             OSErr    myErr;
  3465.             AEDesc   dNull;
  3466.             AEDesc   dDocIndex;
  3467.             short    winIndex;
  3468.             
  3469.             // AEDesc   dDocName;
  3470.             // Str255   windowName;
  3471.             
  3472.             //  Changed from name to index for better playback
  3473.             //  Needed as new windows now have incremental names
  3474.             //    GetWTitle(theWindow, windowName);
  3475.             //  myErr = AECreateDesc(typeChar,(Ptr)&windowName[1], windowName[0], &dDocName);
  3476.             //  CreateObjSpecifier was formName too…
  3477.             
  3478.             myErr = noErr;
  3479.             
  3480.             winIndex = IndexFromWindowPtr(theWindow);
  3481.             
  3482.             if (winIndex==0)
  3483.                 myErr = errAEIllegalIndex;
  3484.             
  3485.             if (myErr==noErr)
  3486.                 myErr = CreateOffsetDescriptor(winIndex, &dDocIndex);
  3487.             
  3488.             if (myErr==noErr) 
  3489.                 myErr = AECreateDesc(typeNull, nil , 0, &dNull);
  3490.             
  3491.             if (myErr==noErr) 
  3492.                 myErr = CreateObjSpecifier(cWindow, &dNull, formAbsolutePosition, &dDocIndex, true, dMyDoc);
  3493.             
  3494.             return(myErr);
  3495.             
  3496.     } /*MakeWindowObj*/
  3497.     
  3498. pascal OSErr MakeTextObj(WindowPtr theWindow,
  3499.                                                  short     selStart,
  3500.                                                  short     selEnd,
  3501.                                                  AEDesc    *selTextObj)
  3502.     {
  3503.         OSErr    myErr;
  3504.         OSErr    ignoreErr;
  3505.         AEDesc   dMyDoc;
  3506.         AEDesc   startOfs;
  3507.         AEDesc   endOfs;
  3508.         AEDesc   startObj;
  3509.         AEDesc   endObj;
  3510.         AEDesc   rangeDesc;
  3511.         long     startChar;
  3512.         long     endChar;
  3513.         Boolean  spotFlag;
  3514.             
  3515.         myErr = noErr;
  3516.         
  3517.         if (theWindow==nil) 
  3518.             return(noErr);
  3519.             
  3520.         selTextObj->dataHandle = nil;
  3521.         dMyDoc.dataHandle      = nil;
  3522.         startObj.dataHandle    = nil;
  3523.         endObj.dataHandle      = nil;
  3524.         
  3525.         /* 
  3526.             make the window object 
  3527.         */
  3528.         
  3529.         myErr = MakeWindowObj(theWindow, &dMyDoc);
  3530.             
  3531.         if (myErr==noErr)
  3532.             {
  3533.                 /* get the start and end of selection */
  3534.                 
  3535.                 startChar = selStart+1;    /* start counting obj's from 1, not 0 */
  3536.                 endChar   = selEnd;
  3537.                 spotFlag  = (selStart == selEnd);
  3538.                     
  3539.                 myErr = CreateOffsetDescriptor(startChar, &startOfs);
  3540.                             
  3541.                 if (myErr==noErr)
  3542.                     if (spotFlag)
  3543.                         myErr = CreateObjSpecifier(cSpot,
  3544.                                                                              &dMyDoc,
  3545.                                                                              formAbsolutePosition, 
  3546.                                                                              &startOfs, 
  3547.                                                                              true, 
  3548.                                                                              selTextObj);
  3549.                     else
  3550.                         {
  3551.                             /* not a spot - must represent as range */
  3552.                             /* make obj for start char */
  3553.                             
  3554.                             myErr = CreateObjSpecifier(cChar,
  3555.                                                        &dMyDoc,
  3556.                                                                                  formAbsolutePosition,
  3557.                                                                                  &startOfs,
  3558.                                                                                  false,
  3559.                                                                                  &startObj);
  3560.                             
  3561.                             if (myErr==noErr) 
  3562.                                 myErr = CreateOffsetDescriptor(endChar, &endOfs);
  3563.                             
  3564.                             if (myErr==noErr) 
  3565.                                 myErr = CreateObjSpecifier(cChar,
  3566.                                                                                      &dMyDoc,
  3567.                                                                                      formAbsolutePosition,
  3568.                                                                                      &endOfs,
  3569.                                                                                      false,
  3570.                                                                                      &endObj);
  3571.                             
  3572.                             if (myErr==noErr) 
  3573.                                 myErr = CreateRangeDescriptor(&startObj,
  3574.                                                                                             &endObj,
  3575.                                                                                             false,
  3576.                                                                                             &rangeDesc);
  3577.                             
  3578.                             if (myErr==noErr) 
  3579.                                 myErr = CreateObjSpecifier(cChar,
  3580.                                                                                      &dMyDoc,
  3581.                                                                                      formRange,
  3582.                                                                                      &rangeDesc,
  3583.                                                                                      true,
  3584.                                                                                      selTextObj);
  3585.                                                                                      
  3586.                             if (startObj.dataHandle)
  3587.                               ignoreErr = AEDisposeDesc(&startObj);
  3588.                                 
  3589.                             if (startOfs.dataHandle)
  3590.                               ignoreErr = AEDisposeDesc(&startOfs);
  3591.                                 
  3592.                             if (endObj.dataHandle)
  3593.                               ignoreErr = AEDisposeDesc(&endObj);
  3594.                                 
  3595.                             if (endOfs.dataHandle)
  3596.                               ignoreErr = AEDisposeDesc(&endOfs);
  3597.                         }
  3598.             }
  3599.             
  3600.         return(myErr);
  3601.     }
  3602.     
  3603. pascal OSErr MakeSelectedTextObj(WindowPtr theWindow,
  3604.                                                                  TEHandle  theTextEditHandle,
  3605.                                                                  AEDesc    *selTextObj)
  3606.     {
  3607.         return( MakeTextObj(theWindow,
  3608.                                                 (**theTextEditHandle).selStart,
  3609.                                                 (**theTextEditHandle).selEnd,
  3610.                                               selTextObj));
  3611.                                                 
  3612.     }    /* MakeSelectedTextObj */
  3613.  
  3614.  
  3615. /** -----------------------------------------------------------------------
  3616.         Name:             MakeMenuObj
  3617.         Purpose:        Creates a typeObjSpecifier for a named menu.
  3618.      -----------------------------------------------------------------------**/
  3619.  
  3620. pascal OSErr MakeMenuObj(Str255 theName, AEDesc *resultingObj)
  3621.     {
  3622.         AEDesc newDesc;
  3623.         AEDesc dNull;
  3624.         OSErr  theErr;
  3625.         
  3626.         theErr  = AECreateDesc(typeChar,
  3627.                                                      (Ptr)&theName[1],
  3628.                                                      theName[0],
  3629.                                                      &newDesc);
  3630.         if (theErr==noErr)
  3631.             {
  3632.                 theErr = AECreateDesc(typeNull, nil , 0, &dNull);
  3633.                 
  3634.                 theErr = CreateObjSpecifier(cMenu,
  3635.                                                                         &dNull,
  3636.                                                                         formName,
  3637.                                                                         &newDesc,
  3638.                                                                         true,
  3639.                                                                         resultingObj);
  3640.             }
  3641.             
  3642.         return(theErr);
  3643.         
  3644.     } /* MakeMenuObj */
  3645.     
  3646. /** -----------------------------------------------------------------------
  3647.         Name:             MakeMenuItemObj
  3648.         Purpose:        Creates a typeObjSpecifier for a named menu.
  3649.      -----------------------------------------------------------------------**/
  3650.  
  3651. pascal OSErr MakeMenuItemObj(Str255 theName, short theItem, AEDesc *resultingObj)
  3652.     {
  3653.         AEDesc menuDesc;
  3654.         AEDesc dataDesc;
  3655.         
  3656.         OSErr  theErr;
  3657.         
  3658.         theErr  = MakeMenuObj(theName, &menuDesc);
  3659.         
  3660.         if (theErr==noErr)
  3661.             {
  3662.                 theErr = CreateOffsetDescriptor(theItem, &dataDesc);
  3663.                 
  3664.                 theErr = CreateObjSpecifier(cMenu,
  3665.                                                                         &menuDesc,
  3666.                                                                         formAbsolutePosition,
  3667.                                                                         &dataDesc,
  3668.                                                                         true,
  3669.                                                                         resultingObj);
  3670.             }
  3671.             
  3672.         return(theErr);
  3673.     } /* MakeMenuItemObj */
  3674.     
  3675. pascal OSErr MakeClassObj(DescType theClass, AEDesc *myClassObj)
  3676.     {  
  3677.         return(AECreateDesc(typeType,
  3678.                                                      (Ptr)&theClass,
  3679.                                                      sizeof(DescType),
  3680.                                                      myClassObj));
  3681.     } /* MakeClassObj */
  3682.     
  3683. enum editCommandType {
  3684. editCutCommand   = 1,
  3685. editCopyCommand  = 2,
  3686. editPasteCommand = 3,
  3687. editClearCommand = 4
  3688. };
  3689.  
  3690. typedef enum editCommandType editCommandType;
  3691.  
  3692. pascal void DoEditCommand(DPtr theDocument,editCommandType whatCommand);
  3693.  
  3694. pascal void DoEditCommand(DPtr theDocument,editCommandType whatCommand)
  3695.     {
  3696.       OSErr         err;
  3697.       OSErr         forgetErr;
  3698.         AEAddressDesc ourAddress;
  3699.         AppleEvent    editCommandEvent;
  3700.         AppleEvent    ignoreReply;
  3701.         AEDesc        ourTextSelObj;
  3702.         AEEventID     theEventID;
  3703.         AEEventClass  theEventClass;
  3704.  
  3705.         /*
  3706.                 Initialise
  3707.         */
  3708.  
  3709.         ourAddress.dataHandle             = nil;
  3710.         ourTextSelObj.dataHandle         = nil;
  3711.         editCommandEvent.dataHandle = nil;
  3712.         ignoreReply.dataHandle             = nil;
  3713.         
  3714.         err = MakeSelfAddress(&ourAddress);
  3715.         
  3716.         /*
  3717.             Build an object to represent the current document's selection
  3718.         */
  3719.         err = MakeSelectedTextObj(theDocument->theWindow, theDocument->theText, &ourTextSelObj);
  3720.         
  3721.         if (err==noErr)
  3722.           {
  3723.                 switch (whatCommand) {
  3724.                     case  editCutCommand         : theEventID    = kAECut;
  3725.                                                                         theEventClass = kAEMiscStandards;
  3726.                                                                         break;
  3727.                     case  editCopyCommand     : theEventID    = kAECopy;
  3728.                                                                         theEventClass = kAEMiscStandards;
  3729.                                                                         break;
  3730.                     case  editPasteCommand     : theEventID    = kAEPaste;
  3731.                                                                         theEventClass = kAEMiscStandards;
  3732.                                                                         break;
  3733.                     case  editClearCommand     : theEventID    = kAEDelete;
  3734.                                                                         theEventClass = kAECoreSuite;
  3735.                                                                         break;
  3736.                 }
  3737.                     
  3738.                 err = AECreateAppleEvent( theEventClass, theEventID, &ourAddress, 0, 0, &editCommandEvent);    
  3739.  
  3740.                 /* add parameter */    
  3741.                 if (err==noErr) 
  3742.                     err = AEPutParamDesc(&editCommandEvent, keyDirectObject, &ourTextSelObj);
  3743.                     
  3744.                 /*and now Send the message*/
  3745.                 if (err==noErr)
  3746.                     err = AESend(&editCommandEvent,&ignoreReply,kAENoReply,kAENormalPriority,10000,nil, nil);
  3747.             }              
  3748.             
  3749.         /*
  3750.             Clean up
  3751.         */
  3752.         if (ourAddress.dataHandle) 
  3753.             forgetErr = AEDisposeDesc(&ourAddress);
  3754.         
  3755.         if (editCommandEvent.dataHandle) 
  3756.             forgetErr = AEDisposeDesc(&editCommandEvent);
  3757.         
  3758.         if (ignoreReply.dataHandle) 
  3759.             forgetErr = AEDisposeDesc(&ignoreReply);
  3760.             
  3761.         if (ourTextSelObj.dataHandle) 
  3762.             forgetErr = AEDisposeDesc(&ourTextSelObj);
  3763.             
  3764.     } /*DoEditCommand*/
  3765.     
  3766. pascal void IssueCutCommand(DPtr theDocument)
  3767.     {            
  3768.         DoEditCommand(theDocument, editCutCommand);
  3769.     } 
  3770.     
  3771. pascal void IssueCopyCommand(DPtr theDocument)
  3772.     {
  3773.         DoEditCommand(theDocument, editCopyCommand);
  3774.     }
  3775.     
  3776. pascal void IssuePasteCommand(DPtr theDocument)
  3777.     {
  3778.         DoEditCommand(theDocument, editPasteCommand);    
  3779.     }
  3780.     
  3781. pascal void IssueClearCommand(DPtr theDocument)
  3782.     {
  3783.         DoEditCommand(theDocument, editClearCommand);    
  3784.     }
  3785.     
  3786. pascal void IssueFontCommand(DPtr theDocument, short theItem)
  3787.     {
  3788.        Str255         name;
  3789.          AEDesc           strDesc;
  3790.          AEAddressDesc  theAddress;
  3791.          OSErr            err;
  3792.          AEDesc         selTextObj;
  3793.             
  3794.         err = MakeSelfAddress(&theAddress);
  3795.         
  3796.         err = MakeSelectedTextObj(theDocument->theWindow,
  3797.                                                             theDocument->theText,
  3798.                                                             &selTextObj);
  3799.         
  3800.         GetItem(myMenus[fontM], theItem, name);
  3801.         
  3802.         if (err==noErr)
  3803.             err  = AECreateDesc(typeChar,
  3804.                                                     (Ptr)&name[1],
  3805.                                                     name[0],
  3806.                                                     &strDesc);
  3807.         
  3808.         if (err==noErr)
  3809.             err  = SendAESetObjProp(&selTextObj, 
  3810.                                                             pFont,
  3811.                                                             &strDesc,
  3812.                                                             &theAddress);                                                            
  3813.     }
  3814.     
  3815. /*
  3816.     Window property routines
  3817. */
  3818.  
  3819. pascal void IssueZoomCommand(WindowPtr whichWindow, short whichPart)
  3820.     {
  3821.       Boolean       zoomBool;
  3822.         AEDesc        zoomDesc;
  3823.         AEAddressDesc selfAddr;
  3824.         AEDesc        frontWinObj;
  3825.         OSErr         err;
  3826.     
  3827.         err = MakeSelfAddress(&selfAddr);
  3828.         
  3829.         err = MakeWindowObj(whichWindow, &frontWinObj);
  3830.         
  3831.         zoomBool = (whichPart==inZoomOut);
  3832.     
  3833.         err = AECreateDesc(typeBoolean,
  3834.                                              (Ptr)&zoomBool,
  3835.                                              sizeof(zoomBool),
  3836.                                              &zoomDesc);
  3837.                                                 
  3838.         err = SendAESetObjProp(&frontWinObj, 
  3839.                                                      pIsZoomed,
  3840.                                                      &zoomDesc,
  3841.                                                      &selfAddr);                                                            
  3842.     } /* IssueZoomCommand */
  3843.     
  3844. pascal void IssueCloseCommand(WindowPtr whichWindow)
  3845.     {
  3846.         AEAddressDesc  selfAddr;
  3847.         AEDesc         frontWinObj;
  3848.         OSErr          err;
  3849.         OSErr          ignoreErr;
  3850.         AppleEvent     closeCommandEvent;
  3851.         AppleEvent     ignoreReply;
  3852.     
  3853.         frontWinObj.dataHandle = nil;
  3854.         
  3855.         err = MakeSelfAddress(&selfAddr);
  3856.         
  3857.         err = MakeWindowObj(whichWindow, &frontWinObj);
  3858.                                                             
  3859.         err = AECreateAppleEvent( kAECoreSuite, kAEClose, &selfAddr, 0, 0, &closeCommandEvent) ;                
  3860.         
  3861.         /* add parameter - the window to close */    
  3862.         if (err==noErr) 
  3863.             err = AEPutParamDesc(&closeCommandEvent, keyDirectObject, &frontWinObj);
  3864.             
  3865.         if (err==noErr) 
  3866.             err = AESend(&closeCommandEvent,&ignoreReply,kAENoReply+kAEAlwaysInteract,kAENormalPriority,10000,nil, nil);
  3867.         
  3868.         if (closeCommandEvent.dataHandle) 
  3869.             ignoreErr = AEDisposeDesc(&closeCommandEvent);
  3870.         
  3871.         if (frontWinObj.dataHandle) 
  3872.             ignoreErr = AEDisposeDesc(&frontWinObj);
  3873.             
  3874.         if (selfAddr.dataHandle) 
  3875.             ignoreErr = AEDisposeDesc(&selfAddr);
  3876.             
  3877.     } /* IssueCloseCommand */
  3878.     
  3879. pascal void IssueSizeWindow(WindowPtr whichWindow, short newHSize, short newVSize)
  3880.     {
  3881.       Rect          sizeRect;
  3882.         Rect          contentRect;
  3883.         short         edgeSize;
  3884.         AEDesc        sizeDesc;
  3885.         AEAddressDesc selfAddr;
  3886.         AEDesc        frontWinObj;
  3887.         OSErr         err;
  3888.     
  3889.         sizeRect    = (**(((WindowPeek)whichWindow)->strucRgn)).rgnBBox;
  3890.         contentRect = (**(((WindowPeek)whichWindow)->contRgn)).rgnBBox;
  3891.         
  3892.         edgeSize = sizeRect.right-sizeRect.left-(contentRect.right-contentRect.left);
  3893.         sizeRect.right = sizeRect.left+newHSize+edgeSize;
  3894.         
  3895.         edgeSize = sizeRect.bottom-sizeRect.top-(contentRect.bottom-contentRect.top);
  3896.         sizeRect.bottom = sizeRect.top+newVSize+edgeSize;
  3897.         
  3898.         err = MakeSelfAddress(&selfAddr);
  3899.         
  3900.         err = MakeWindowObj(whichWindow, &frontWinObj);
  3901.         
  3902.         if (err==noErr)
  3903.             err = AECreateDesc(typeQDRectangle,
  3904.                                                  (Ptr)&sizeRect,
  3905.                                                  sizeof(sizeRect),
  3906.                                                  &sizeDesc);
  3907.         
  3908.         if (err==noErr)
  3909.             err  = SendAESetObjProp(&frontWinObj, 
  3910.                                                             pBounds,
  3911.                                                             &sizeDesc,
  3912.                                                             &selfAddr);                                                            
  3913.     } /*IssueSizeWindow*/
  3914.     
  3915. pascal void IssueMoveWindow(WindowPtr whichWindow, Rect sizeRect)
  3916.     {
  3917.         AEDesc        sizeDesc;
  3918.         AEAddressDesc selfAddr;
  3919.         AEDesc        frontWinObj;
  3920.         OSErr         err;
  3921.     
  3922.         err = MakeSelfAddress(&selfAddr);
  3923.         
  3924.         err = MakeWindowObj(whichWindow, &frontWinObj);
  3925.             
  3926.         if (err==noErr)
  3927.             err = AECreateDesc(typeQDRectangle,
  3928.                                                  (Ptr)&sizeRect,
  3929.                                                  sizeof(sizeRect),
  3930.                                                  &sizeDesc);
  3931.         
  3932.         if (err==noErr)        
  3933.             err = SendAESetObjProp(&frontWinObj, 
  3934.                                                          pBounds,
  3935.                                                          &sizeDesc,
  3936.                                                          &selfAddr);                                                            
  3937.     } /*IssueMoveWindow*/
  3938.  
  3939. pascal void IssuePageSetupWindow(WindowPtr whichWindow, TPrint thePageSetup)
  3940.     {
  3941.         AEDesc        sizeDesc;
  3942.         AEAddressDesc selfAddr;
  3943.         AEDesc        frontWinObj;
  3944.         OSErr         err;
  3945.     
  3946.         err = MakeSelfAddress(&selfAddr);
  3947.         
  3948.         err = MakeWindowObj(whichWindow, &frontWinObj);
  3949.         
  3950.         if (err==noErr)
  3951.             err = AECreateDesc(typeTPrint,
  3952.                                                  (Ptr)&thePageSetup,
  3953.                                                  sizeof(thePageSetup),
  3954.                                                  &sizeDesc);
  3955.                                                  
  3956.         if (err==noErr)
  3957.             err = SendAESetObjProp(&frontWinObj, 
  3958.                                                          pPageSetup,
  3959.                                                          &sizeDesc,
  3960.                                                          &selfAddr);                                                            
  3961.                                                      
  3962.     } /*IssuePageSetupWindow*/
  3963.  
  3964.     
  3965. pascal void IssuePrintWindow(WindowPtr whichWindow)
  3966.     {
  3967.         AEAddressDesc selfAddr;
  3968.         AEDesc        frontWinObj;
  3969.         OSErr         err;
  3970.         OSErr         ignoreErr;
  3971.         AppleEvent    printCommandEvent;
  3972.         AppleEvent    ignoreReply;
  3973.     
  3974.         err = MakeSelfAddress(&selfAddr);
  3975.         
  3976.         err = MakeWindowObj(whichWindow, &frontWinObj);
  3977.                                                             
  3978.         err = AECreateAppleEvent(kCoreEventClass, kAEPrintDocuments, &selfAddr, 0, 0, &printCommandEvent) ;                
  3979.  
  3980.         /* 
  3981.             add parameter - the window to print
  3982.         */    
  3983.  
  3984.         if (err==noErr) 
  3985.             err = AEPutParamDesc(&printCommandEvent, keyDirectObject, &frontWinObj);
  3986.             
  3987.         if (err==noErr) 
  3988.             err = AESend(&printCommandEvent,&ignoreReply,kAENoReply+kAEAlwaysInteract,kAENormalPriority,10000,nil, nil);
  3989.     
  3990.       if (printCommandEvent.dataHandle)
  3991.             ignoreErr = AEDisposeDesc(&printCommandEvent);
  3992.         
  3993.         if (frontWinObj.dataHandle) 
  3994.             ignoreErr = AEDisposeDesc(&frontWinObj);
  3995.             
  3996.         if (selfAddr.dataHandle) 
  3997.             ignoreErr = AEDisposeDesc(&selfAddr);
  3998.             
  3999.     } /*IssuePrintWindow*/
  4000.     
  4001. pascal OSErr IssueAEOpenDoc(FSSpec myFSSpec)
  4002. /* send OpenDocs AppleEvent to myself, with a one-element list
  4003.   containing the given file spec
  4004.  
  4005.   NOTES : the core AEOpenDocs event is defined as taking a list of
  4006.           aliases (not file specs) as its direct parameter.  However,
  4007.             we can send the file spec instead and depend on AppleEvents'
  4008.             automatic coercion.  In fact, we don't really even have to put 
  4009.             in a list; AppleEvents will coerce a descriptor into a 1-element
  4010.             list if called for.  In this routine, though, we'll make the
  4011.             list for demonstration purposes.
  4012. */
  4013.  
  4014.  {
  4015.          AppleEvent    myAppleEvent;
  4016.         AppleEvent    defReply;
  4017.         AEDescList    docList;
  4018.         AEAddressDesc selfAddr;
  4019.         OSErr         myErr;
  4020.         OSErr         ignoreErr;
  4021.         
  4022.         myAppleEvent.dataHandle = nil;
  4023.         docList.dataHandle  = nil;
  4024.         selfAddr.dataHandle = nil;
  4025.         defReply.dataHandle = nil;
  4026.             
  4027.         /*
  4028.             Create empty list and add one file spec
  4029.         */
  4030.         myErr = AECreateList(nil,0,false, &docList);
  4031.         
  4032.         if (myErr==noErr) 
  4033.             myErr = AEPutPtr(&docList,1,typeFSS,(Ptr)&myFSSpec,sizeof(myFSSpec));
  4034.             
  4035.         /*
  4036.             Create a self address to send it to
  4037.         */
  4038.         if (myErr==noErr) 
  4039.             myErr = MakeSelfAddress(&selfAddr);
  4040.             
  4041.         if (myErr==noErr) 
  4042.             myErr = AECreateAppleEvent(kCoreEventClass,
  4043.                                                                  kAEOpenDocuments,
  4044.                                                                  &selfAddr,
  4045.                                                                  kAutoGenerateReturnID,
  4046.                                                                  kAnyTransactionID,
  4047.                                                                  &myAppleEvent);
  4048.     
  4049.         /* 
  4050.             Put Params into our event and send it
  4051.         */
  4052.         if (myErr == noErr) 
  4053.             myErr = AEPutParamDesc(&myAppleEvent,
  4054.                                                          keyDirectObject,
  4055.                                                          &docList);
  4056.     
  4057.         myErr = AESend(&myAppleEvent,
  4058.                                      &defReply,
  4059.                                      kAENoReply+kAEAlwaysInteract,
  4060.                                      kAENormalPriority,
  4061.                                      kAEDefaultTimeout,
  4062.                                      nil,
  4063.                                      nil);
  4064.             
  4065.         if (selfAddr.dataHandle) 
  4066.             ignoreErr = AEDisposeDesc(&selfAddr);
  4067.             
  4068.         if (myAppleEvent.dataHandle) 
  4069.             ignoreErr = AEDisposeDesc(&myAppleEvent);
  4070.             
  4071.         if (docList.dataHandle) 
  4072.             ignoreErr = AEDisposeDesc(&docList);
  4073.             
  4074.         return(myErr);
  4075.         
  4076.     }    /* IssueAEOpenDoc */
  4077.  
  4078. pascal void IssueAENewWindow(void)
  4079. /* 
  4080.     send the New Element event to myself with a null container
  4081. */
  4082.     {
  4083.       AppleEvent    myAppleEvent;
  4084.         AppleEvent    defReply;
  4085.         AEAddressDesc selfAddr;
  4086.         OSErr         myErr;
  4087.         OSErr         ignoreErr;
  4088.         DescType      elemClass;
  4089.         
  4090.         myAppleEvent.dataHandle = nil;
  4091.         
  4092.         /*
  4093.             Create the address of us
  4094.         */
  4095.         
  4096.         myErr = MakeSelfAddress(&selfAddr);
  4097.         
  4098.         /*
  4099.             create event 
  4100.         */
  4101.         
  4102.         myErr = AECreateAppleEvent(kAECoreSuite,
  4103.                                                              kAECreateElement,
  4104.                                                              &selfAddr,
  4105.                                                              kAutoGenerateReturnID,
  4106.                                                              kAnyTransactionID,
  4107.                                                              &myAppleEvent);
  4108.         
  4109.         /*
  4110.             attach desired class of new element
  4111.         */
  4112.         
  4113.         elemClass = cWindow;
  4114.         
  4115.         if (myErr == noErr) 
  4116.             myErr = AEPutParamPtr(&myAppleEvent,
  4117.                                                       keyAEObjectClass,
  4118.                                                         typeType,
  4119.                                                         (Ptr)&elemClass,
  4120.                                                         sizeof(elemClass));
  4121.             
  4122.         /*
  4123.             send the event 
  4124.         */
  4125.         
  4126.         if (myErr == noErr) 
  4127.             myErr = AESend(&myAppleEvent,
  4128.                                          &defReply,
  4129.                                          kAENoReply+kAENeverInteract,
  4130.                                          kAENormalPriority,
  4131.                                          kAEDefaultTimeout,
  4132.                                          nil,
  4133.                                          nil);
  4134.         /*
  4135.             Clean up - reply never created so don't throw away
  4136.         */
  4137.         if (selfAddr.dataHandle) 
  4138.             ignoreErr = AEDisposeDesc(&selfAddr);
  4139.             
  4140.         if (myAppleEvent.dataHandle) 
  4141.             ignoreErr = AEDisposeDesc(&myAppleEvent);
  4142.                     
  4143.     }    /* IssueAENewWindow */
  4144.  
  4145. pascal OSErr IssueSaveCommand(WindowPtr theWindow,
  4146.                               FSSpecPtr where)
  4147. /*
  4148.     send an AppleEvent Save Event to myself
  4149. */
  4150.  
  4151. {
  4152.     AEDesc        windowObj;
  4153.     AppleEvent    myAppleEvent;
  4154.     AppleEvent    defReply;
  4155.     OSErr         myErr;
  4156.     OSErr         ignoreErr;
  4157.     AEAddressDesc selfAddr;
  4158.         
  4159.     windowObj.dataHandle = nil;
  4160.     myAppleEvent.dataHandle = nil;
  4161.     
  4162.     myErr = MakeWindowObj(theWindow, &windowObj);
  4163.             
  4164.     if (myErr==noErr) 
  4165.         myErr = MakeSelfAddress(&selfAddr);
  4166.         
  4167.   /*
  4168.         Build event
  4169.     */
  4170.     
  4171.   if (myErr == noErr) 
  4172.         myErr = AECreateAppleEvent(kAECoreSuite,
  4173.                                                              kAESave,
  4174.                                                              &selfAddr,
  4175.                                                              kAutoGenerateReturnID,
  4176.                                                              kAnyTransactionID,
  4177.                                                              &myAppleEvent);
  4178.       
  4179.   /*
  4180.         say which window
  4181.     */
  4182.     
  4183.   if (myErr==noErr) 
  4184.         myErr = AEPutParamDesc(&myAppleEvent,
  4185.                                                      keyDirectObject,
  4186.                                                      &windowObj);
  4187.   
  4188.   /*
  4189.         add optional file param if we need to
  4190.     */
  4191.     
  4192.   if (where) 
  4193.         if (myErr==noErr) 
  4194.             myErr = AEPutParamPtr(&myAppleEvent,
  4195.                                                         keyAEDestination,
  4196.                                                         typeFSS,
  4197.                                                         (Ptr)where,
  4198.                                                         sizeof(FSSpec));
  4199.         
  4200.   /*
  4201.         send the event
  4202.     */
  4203.   if (myErr==noErr) 
  4204.         myErr  = AESend(&myAppleEvent,
  4205.                                         &defReply,
  4206.                                         kAENoReply+kAENeverInteract,
  4207.                                         kAENormalPriority,
  4208.                                         kAEDefaultTimeout,
  4209.                                         nil,
  4210.                                         nil);
  4211.       
  4212.     if (selfAddr.dataHandle) 
  4213.         ignoreErr = AEDisposeDesc(&selfAddr);
  4214.       
  4215.     if (windowObj.dataHandle) 
  4216.         ignoreErr = AEDisposeDesc(&windowObj);
  4217.         
  4218.     if (myAppleEvent.dataHandle) 
  4219.         ignoreErr = AEDisposeDesc(&myAppleEvent);
  4220.         
  4221.     return(myErr);
  4222. }    /* IssueSaveCommand */
  4223.  
  4224. pascal void IssueSelectWindowCommand(WindowPtr theWindow, WindowPtr oldFrontWindow)
  4225. /*
  4226.     send an AppleEvent Move Event to ourself to select the chosen window
  4227.     i.e. bring it to the front. This is the same as move before the front window.
  4228. */
  4229.  
  4230. {
  4231.     AEDesc        windowObj;
  4232.     AEDesc        fWinObj;
  4233.     AEDesc        theDestObject;
  4234.     AEDesc        theDestRecord;
  4235.     DescType      thePosn;
  4236.     AppleEvent    myAppleEvent;
  4237.     AppleEvent    defReply;
  4238.     OSErr         myErr;
  4239.     OSErr         ignoreErr;
  4240.     AEAddressDesc selfAddr;
  4241.         
  4242.     windowObj.dataHandle    = nil;
  4243.     myAppleEvent.dataHandle = nil;
  4244.     
  4245.     myErr = MakeWindowObj(theWindow, &windowObj);
  4246.             
  4247.     if (myErr==noErr) 
  4248.         myErr = MakeSelfAddress(&selfAddr);
  4249.         
  4250.   /*
  4251.         Build event
  4252.     */
  4253.     
  4254.   if (myErr == noErr) 
  4255.         myErr = AECreateAppleEvent(kAECoreSuite,
  4256.                                                              kAEMove,
  4257.                                                              &selfAddr,
  4258.                                                              kAutoGenerateReturnID,
  4259.                                                              kAnyTransactionID,
  4260.                                                              &myAppleEvent);
  4261.       
  4262.   /*
  4263.         say which window
  4264.     */
  4265.     
  4266.   if (myErr==noErr) 
  4267.         myErr = AEPutParamDesc(&myAppleEvent,
  4268.                                                      keyDirectObject,
  4269.                                                      &windowObj);
  4270.   
  4271.   /*
  4272.         add to where param - typeInsertionLoc
  4273.     */
  4274.     
  4275.     if (myErr==noErr)
  4276.         {
  4277.             // Build a record
  4278.             
  4279.             theDestRecord.dataHandle = nil;
  4280.             theDestObject.dataHandle = nil;
  4281.             fWinObj.dataHandle       = nil;
  4282.             
  4283.             myErr = AECreateList(nil, 0, true, &theDestRecord);
  4284.             
  4285.             if (myErr==noErr)
  4286.                 { // add the reference object - the current front window
  4287.  
  4288.                     myErr = MakeWindowObj(oldFrontWindow, &fWinObj);
  4289.                     
  4290.                     if (myErr==noErr)
  4291.                         myErr = AEPutKeyDesc(&theDestRecord,
  4292.                                                                  keyAEObject,
  4293.                                                                  &fWinObj);
  4294.                     
  4295.                     if (fWinObj.dataHandle)
  4296.                         ignoreErr = AEDisposeDesc(&fWinObj);
  4297.                 }
  4298.             
  4299.             // How to place it relative to the reference object
  4300.             thePosn = kAEBefore;
  4301.             
  4302.             if (myErr==noErr)
  4303.                 myErr = AEPutKeyPtr(&theDestRecord,
  4304.                                                       keyAEPosition,
  4305.                                                       typeEnumeration,
  4306.                                                       (Ptr)&thePosn,
  4307.                                                       sizeof(thePosn));
  4308.             
  4309.             if (myErr==noErr)
  4310.                 myErr = AECoerceDesc(&theDestRecord, typeInsertionLoc, &theDestObject);
  4311.             
  4312.             if (theDestRecord.dataHandle)
  4313.                 ignoreErr = AEDisposeDesc(&theDestRecord);
  4314.             
  4315.             if (myErr==noErr)
  4316.                 myErr = AEPutParamDesc(&myAppleEvent,
  4317.                                                              keyAEInsertHere,
  4318.                                                              &theDestObject);
  4319.                                                          
  4320.             if (theDestObject.dataHandle)
  4321.                 ignoreErr = AEDisposeDesc(&theDestObject);
  4322.         }
  4323.         
  4324.   /*
  4325.         send the event
  4326.     */
  4327.   if (myErr==noErr) 
  4328.         myErr  = AESend(&myAppleEvent,
  4329.                                         &defReply,
  4330.                                         kAENoReply+kAEDontExecute,
  4331.                                         kAENormalPriority,
  4332.                                         kAEDefaultTimeout,
  4333.                                         nil,
  4334.                                         nil);
  4335.       
  4336.     if (selfAddr.dataHandle) 
  4337.         ignoreErr = AEDisposeDesc(&selfAddr);
  4338.       
  4339.     if (windowObj.dataHandle) 
  4340.         ignoreErr = AEDisposeDesc(&windowObj);
  4341.         
  4342.     if (myAppleEvent.dataHandle) 
  4343.         ignoreErr = AEDisposeDesc(&myAppleEvent);
  4344.         
  4345. }    /* IssueSelectWindowCommand */
  4346.  
  4347. pascal OSErr IssueRevertCommand(WindowPtr theWindow)
  4348. /*
  4349.     send an AppleEvent Revert Event to myself
  4350. */
  4351.  
  4352.     {
  4353.         AEDesc        windowObj;
  4354.         AppleEvent    myAppleEvent;
  4355.         AppleEvent    defReply;
  4356.         OSErr         myErr;
  4357.         OSErr         ignoreErr;
  4358.         AEAddressDesc selfAddr;
  4359.         
  4360.         windowObj.dataHandle = nil;
  4361.         myAppleEvent.dataHandle = nil;
  4362.         
  4363.         myErr = MakeWindowObj(theWindow, &windowObj);
  4364.                     
  4365.         if (myErr==noErr) 
  4366.             myErr = MakeSelfAddress(&selfAddr);
  4367.             
  4368.         /*
  4369.             Build event
  4370.         */
  4371.         
  4372.         if (myErr == noErr) 
  4373.             myErr  = AECreateAppleEvent(kAEMiscStandards,
  4374.                                                                     kAERevert,
  4375.                                                                     &selfAddr,
  4376.                                                                     kAutoGenerateReturnID,
  4377.                                                                     kAnyTransactionID,
  4378.                                                                     &myAppleEvent);
  4379.         /*
  4380.             say which window
  4381.         */
  4382.         
  4383.         if (myErr == noErr) 
  4384.             myErr = AEPutParamDesc(&myAppleEvent,
  4385.                                                          keyDirectObject,
  4386.                                                          &windowObj);
  4387.         /*
  4388.             send the event
  4389.         */
  4390.         if (myErr==noErr) 
  4391.             myErr  = AESend(&myAppleEvent,
  4392.                                             &defReply,
  4393.                                             kAENoReply+kAENeverInteract,
  4394.                                             kAENormalPriority,
  4395.                                             kAEDefaultTimeout,
  4396.                                             nil,
  4397.                                             nil);
  4398.             
  4399.         if (windowObj.dataHandle) 
  4400.             ignoreErr = AEDisposeDesc(&windowObj);
  4401.             
  4402.         if (myAppleEvent.dataHandle) 
  4403.             ignoreErr = AEDisposeDesc(&myAppleEvent);
  4404.             
  4405.         if (selfAddr.dataHandle) 
  4406.             ignoreErr = AEDisposeDesc(&selfAddr);
  4407.             
  4408.         return(myErr);
  4409.     }    /* IssueRevertCommand */
  4410.  
  4411. /*
  4412.     Name : IssueQuitCommand
  4413.     Purpose : Sends self a Quit AppleEvent
  4414. */
  4415. pascal OSErr IssueQuitCommand(void)
  4416.     {
  4417.         AppleEvent    myAppleEvent;
  4418.         AppleEvent    defReply;
  4419.         OSErr         myErr;
  4420.         OSErr         ignoreErr;
  4421.         AEAddressDesc selfAddr;
  4422.         DescType      mySaveOpt;
  4423.         
  4424.         myAppleEvent.dataHandle = nil;
  4425.         selfAddr.dataHandle     = nil;
  4426.                             
  4427.         myErr = MakeSelfAddress(&selfAddr);
  4428.             
  4429.         /*
  4430.             Build event
  4431.         */
  4432.         
  4433.         if (myErr == noErr) 
  4434.             myErr  = AECreateAppleEvent(kCoreEventClass,
  4435.                                                                     kAEQuitApplication,
  4436.                                                                     &selfAddr,
  4437.                                                                     kAutoGenerateReturnID,
  4438.                                                                     kAnyTransactionID,
  4439.                                                                     &myAppleEvent);
  4440.         /*
  4441.             say which save option
  4442.         */
  4443.         
  4444.         mySaveOpt = kAEAsk;
  4445.         
  4446.         if (myErr == noErr) 
  4447.             myErr = AEPutParamPtr(&myAppleEvent,
  4448.                                                         keyAESaveOptions,
  4449.                                                         typeEnumerated,
  4450.                                                         (Ptr)&mySaveOpt,
  4451.                                                         sizeof(mySaveOpt));
  4452.         /*
  4453.             send the event
  4454.         */
  4455.         if (myErr==noErr) 
  4456.             myErr  = AESend(&myAppleEvent,
  4457.                                             &defReply,
  4458.                                             kAENoReply+kAEAlwaysInteract,
  4459.                                             kAENormalPriority,
  4460.                                             kAEDefaultTimeout,
  4461.                                             nil,
  4462.                                             nil);
  4463.                         
  4464.         if (myAppleEvent.dataHandle) 
  4465.             ignoreErr = AEDisposeDesc(&myAppleEvent);
  4466.             
  4467.         if (selfAddr.dataHandle) 
  4468.             ignoreErr = AEDisposeDesc(&selfAddr);
  4469.             
  4470.         return(myErr);
  4471.     }    /* IssueQuitCommand */
  4472.  
  4473.     
  4474. #define kOK 1
  4475. #define kCancel 2
  4476. #define kOtherSize 4
  4477. #define kOutlineItem 5
  4478.  
  4479. pascal Boolean PoseSizeDialog(long *whatSize);
  4480.  
  4481. pascal Boolean PoseSizeDialog(long *whatSize)
  4482.   {
  4483.       GrafPtr   savedPort;
  4484.     DialogPtr aDialog;
  4485.       Str255    aString;
  4486.       short     itemHit;
  4487.  
  4488.         GetPort(&savedPort);
  4489.         aDialog = GetNewDialog(1004, nil, (WindowPtr)-1);
  4490.         ShowWindow(aDialog);
  4491.         SetPort(aDialog);
  4492.         
  4493.         AdornDefaultButton(aDialog, kOutlineItem);
  4494.          
  4495.         /*set the edittext button to contain the right size*/
  4496.         NumToString(*whatSize, aString);
  4497.         SetText(aDialog, kOtherSize, aString);
  4498.      
  4499.         do {
  4500.             ModalDialog(nil, &itemHit);
  4501.         } while ((itemHit!=kOK) && (itemHit!=kCancel));
  4502.         
  4503.         if (itemHit == kOK) 
  4504.             RetrieveText(aDialog, kOtherSize, aString);
  4505.     
  4506.         DisposDialog(aDialog);
  4507.         SetPort(savedPort);
  4508.         
  4509.         if (itemHit == kOK) 
  4510.          {
  4511.              /*set the new size of the text*/
  4512.              StringToNum(aString, whatSize);
  4513.              if ((*whatSize<1) || (*whatSize>2000)) 
  4514.                  *whatSize = 12;
  4515.          }
  4516.         return(itemHit == kOK);
  4517.     }
  4518.     
  4519. pascal void IssueSizeCommand(DPtr theDocument,short theItem)
  4520.     {
  4521.         Str255        name;
  4522.         AEDesc        sizeDesc;
  4523.         AEAddressDesc theAddress;
  4524.         OSErr         err;
  4525.         AEDesc        selTextObj;
  4526.         
  4527.         /*
  4528.             Vars to do with menu processing
  4529.         */
  4530.         short     lastSize;
  4531.         short     upItem;
  4532.         short     downItem;
  4533.         short     otherItem;
  4534.         long      theSize;
  4535.         TextStyle theStyle;
  4536.         short     lineHeight;
  4537.         short     fontAscent;
  4538.             
  4539.         err = MakeSelfAddress(&theAddress);
  4540.         
  4541.         err = MakeSelectedTextObj(theDocument->theWindow, theDocument->theText, &selTextObj);        
  4542.  
  4543.      /*check if the item is on the Size menu*/
  4544.      /*remembering that we can add and delete items from it*/
  4545.      lastSize  = CountMItems(myMenus[sizeM]) - 5;
  4546.      upItem    = lastSize + 2;
  4547.      downItem  = upItem + 1;
  4548.      otherItem = downItem + 2;
  4549.       
  4550.      TEGetStyle((**(theDocument->theText)).selStart,
  4551.                 &theStyle,
  4552.                             &lineHeight,
  4553.                             &fontAscent,
  4554.                             theDocument->theText);
  4555.         
  4556.      GetItem(myMenus[sizeM], theItem, name);
  4557.      
  4558.      if (theItem <= lastSize)
  4559.        {
  4560.          GetItem(myMenus[sizeM], theItem, name);
  4561.        StringToNum(name, &theSize);
  4562.        }
  4563.      else
  4564.        if (theItem == upItem)  
  4565.             theSize = theStyle.tsSize+1;
  4566.          else
  4567.             if (theItem == downItem)
  4568.                       theSize = theStyle.tsSize-1;
  4569.                  else 
  4570.                     if (theItem == otherItem) 
  4571.                         {
  4572.                           theSize = theStyle.tsSize;
  4573.                             if (!PoseSizeDialog(&theSize))
  4574.                                 return;
  4575.                         }
  4576.  
  4577.         if (err==noErr)
  4578.           err = CreateOffsetDescriptor(theSize, &sizeDesc);
  4579.             
  4580.         if (err==noErr)
  4581.             err = SendAESetObjProp(&selTextObj, 
  4582.                                                          pPointSize,
  4583.                                                          &sizeDesc,
  4584.                                                          &theAddress);
  4585.                                                      
  4586.     } /*IssueSizeCommand*/
  4587.     
  4588. pascal void IssueStyleCommand(DPtr theDocument, short theItem)
  4589.     {
  4590.         Style         theFace;
  4591.         OSErr         err;
  4592.         AEDesc        result;
  4593.         AEAddressDesc selfAddr;
  4594.         AEDesc        selTextObj;
  4595.         TextStyle     theStyle;
  4596.         short         lineHeight;
  4597.         short         fontAscent;
  4598.             
  4599.         TEGetStyle((**(theDocument->theText)).selStart,
  4600.                    &theStyle,
  4601.                              &lineHeight,
  4602.                              &fontAscent,
  4603.                              theDocument->theText);
  4604.         
  4605.         theFace = 0;
  4606.     switch (theItem) {
  4607.             case cPlain              : theFace = 0;
  4608.                                 break;
  4609.             case cBold                : theFace = bold;
  4610.                                 break;
  4611.             case cItalic            : theFace = italic;
  4612.                                 break;
  4613.             case cUnderline      : theFace = underline;
  4614.                                 break;
  4615.             case cOutline          : theFace = outline;
  4616.                                 break;
  4617.             case cShadow            : theFace = shadow;
  4618.                                 break;
  4619.             case cCondense        : theFace = condense;
  4620.                                 break;
  4621.             case cExtend            : theFace = extend;
  4622.                                 break;
  4623.     } /*of case */
  4624.  
  4625.     if (theFace==0)
  4626.             err = BuildTypeTextStylesDesc(0, bold+italic+underline+outline+shadow+condense+extend, &result);
  4627.     else
  4628.       if (theFace & theStyle.tsFace)
  4629.               err = BuildTypeTextStylesDesc(0, theFace, &result);
  4630.             else
  4631.               err = BuildTypeTextStylesDesc(theFace, 0, &result);
  4632.                 
  4633.         err = MakeSelfAddress(&selfAddr);
  4634.         
  4635.         if (err==noErr)
  4636.             err = MakeSelectedTextObj(theDocument->theWindow, theDocument->theText, &selTextObj);
  4637.         
  4638.         if (err==noErr)
  4639.             err = SendAESetObjProp(&selTextObj, 
  4640.                                                          pTextStyles,
  4641.                                                          &result,
  4642.                                                          &selfAddr);
  4643.         
  4644.     } /* IssueStyleCommand */
  4645.     
  4646. enum {
  4647.  
  4648. ETX = 0x03, /* Enter key on keyboard or keypad */
  4649. BS  = 0x08, /* Backspace key on keyboard       */
  4650. HT  = 0x09, /* Tab key on keyboard             */
  4651. CR  = 0x0D, /* Return key on keyboard          */
  4652. ESC = 0x1B, /* Clear key on keypad             */
  4653. FS  = 0x1C, /* Left arrow key on keypad        */
  4654. GS  = 0x1D, /* Right arrow key on keypad       */
  4655. RS  = 0x1E, /* Up arrow key on keypad          */
  4656. US  = 0x1F  /* Down arrow key on keypad        */
  4657. };
  4658.  
  4659. pascal OSErr IssueSetDataObjToBufferContents(const AEDesc * theObj)
  4660.     { 
  4661.       OSErr         myErr;
  4662.         OSErr                    ignoreErr;
  4663.         AEAddressDesc theAddress;
  4664.         AppleEvent    myAppleEvent;
  4665.         AppleEvent    defReply;
  4666.  
  4667.         myErr = MakeSelfAddress(&theAddress);
  4668.         
  4669.         /* create event */
  4670.         
  4671.         if (myErr==noErr)
  4672.             myErr = AECreateAppleEvent(kAECoreSuite,
  4673.                                                                  kAESetData,
  4674.                                                                  &theAddress,
  4675.                                                                  0,
  4676.                                                                  0,
  4677.                                                                  &myAppleEvent);
  4678.             
  4679.         /* add prop obj spec to the event */
  4680.         
  4681.         if (myErr==noErr)
  4682.             myErr = AEPutParamDesc(&myAppleEvent, keyDirectObject, theObj);
  4683.         
  4684.         /* add prop data to the event */
  4685.         
  4686.         if (myErr==noErr)
  4687.             myErr = AEPutParamPtr(&myAppleEvent,
  4688.                                                         keyAEData,
  4689.                                                         typeChar,
  4690.                                                         (Ptr)gTypingBuffer,
  4691.                                                         gCharsInBuffer);
  4692.                                                         
  4693.         /* send event */
  4694.         
  4695.         if (myErr==noErr)
  4696.             myErr = AESend(&myAppleEvent,
  4697.                                          &defReply,
  4698.                                          kAENoReply+kAEDontExecute,
  4699.                                          kAENormalPriority,
  4700.                                          kAEDefaultTimeout,
  4701.                                          nil,
  4702.                                          nil);
  4703.  
  4704.         if (theAddress.dataHandle)
  4705.             ignoreErr = AEDisposeDesc(&theAddress);
  4706.             
  4707.         if (myAppleEvent.dataHandle)
  4708.             ignoreErr = AEDisposeDesc(&myAppleEvent);
  4709.             
  4710.         return(myErr);
  4711.     }
  4712.  
  4713. pascal void AddKeyToTypingBuffer(DPtr theDocument, char theKey)
  4714.     {
  4715.         OSErr myErr;
  4716.         OSErr ignoreErr;
  4717.         
  4718.         if (theKey==BS || theKey==FS || theKey==GS || theKey==RS || theKey==US)
  4719.             {
  4720.                 FlushAndRecordTypingBuffer();
  4721.                 if (theKey==BS)
  4722.                     {
  4723.                         if ((**theDocument->theText).selStart!=(**theDocument->theText).selEnd)
  4724.                             {
  4725.                                 myErr = MakeTextObj(theDocument->theWindow,
  4726.                                                                         (**theDocument->theText).selStart,
  4727.                                                                         (**theDocument->theText).selEnd,
  4728.                                                                         &gTypingTargetObject);
  4729.                             }
  4730.                         else
  4731.                             {
  4732.                                 myErr = MakeTextObj(theDocument->theWindow,
  4733.                                                                         (**theDocument->theText).selStart-1,
  4734.                                                                         (**theDocument->theText).selStart,
  4735.                                                                         &gTypingTargetObject);
  4736.                             }
  4737.                             
  4738.                     myErr = IssueSetDataObjToBufferContents(&gTypingTargetObject);
  4739.                         
  4740.                         ignoreErr = AEDisposeDesc(&gTypingTargetObject);
  4741.                         
  4742.                         gTypingTargetObject.dataHandle = nil;
  4743.                     }
  4744.             }
  4745.         else
  4746.             {
  4747.                 if (gCharsInBuffer==0)
  4748.                     myErr = MakeSelectedTextObj(theDocument->theWindow,
  4749.                                                                             theDocument->theText,
  4750.                                                                             &gTypingTargetObject);
  4751.  
  4752.                 gTypingBuffer[gCharsInBuffer++] = theKey;
  4753.             }
  4754.           
  4755.     }
  4756.     
  4757. pascal void FlushAndRecordTypingBuffer(void)
  4758.     { 
  4759.       OSErr  myErr;
  4760.         OSErr  ignoreErr;
  4761.  
  4762.         if (gCharsInBuffer != 0)
  4763.             {
  4764.                 myErr = IssueSetDataObjToBufferContents(&gTypingTargetObject);
  4765.                 
  4766.                 if (gTypingTargetObject.dataHandle)
  4767.                     ignoreErr = AEDisposeDesc(&gTypingTargetObject);
  4768.             }
  4769.             
  4770.         gCharsInBuffer = 0;
  4771.         gTypingTargetObject.dataHandle = 0;
  4772.     }
  4773.     
  4774. /*****************************************************************************/
  4775. /*
  4776.     Object Accessors
  4777. */
  4778.     
  4779. pascal OSErr WindowFromNullAccessor(DescType      wantClass,
  4780.                                                                     const AEDesc  *container,
  4781.                                                                         DescType      containerClass,
  4782.                                                                         DescType      form, 
  4783.                                                                         const AEDesc  *selectionData,
  4784.                                                                         AEDesc        *value,
  4785.                                                                         long          theRefCon)
  4786.     {
  4787. #pragma unused (container,theRefCon)
  4788.     
  4789.         OSErr       myErr;
  4790.         Str255      nameStr;
  4791.         WindowToken theWindow;
  4792.         short       index;
  4793.         AEDesc      resultDesc;
  4794.         
  4795.         myErr = errAEBadKeyForm;    /* or whatever */
  4796.         
  4797.         value->dataHandle     = nil;
  4798.         resultDesc.dataHandle = nil;
  4799.         
  4800.         /* 
  4801.             should only be called with wantClass = cWindow and
  4802.             with containerClass = typeNull or typeMyAppl.
  4803.             Currently accept as either formName or formAbsolutePosition
  4804.         */
  4805.         
  4806.         if ((wantClass != cWindow) || 
  4807.               ((containerClass != typeNull) && (containerClass != typeMyAppl)) ||
  4808.                !((form == formName) || (form == formAbsolutePosition)))
  4809.             return(errAEWrongDataType);
  4810.         
  4811.         if (form == formName)
  4812.             {
  4813.                 myErr     = GetPStringFromDescriptor(selectionData, (char *)nameStr);
  4814.                 theWindow = WindowNameToWindowPtr(nameStr);
  4815.             }
  4816.         
  4817.         if (form == formAbsolutePosition)
  4818.             {
  4819.                 myErr         = GetIntegerFromDescriptor(selectionData, &index);
  4820.                 
  4821.                 if (index<0)
  4822.                     index = CountWindows()+index+1;
  4823.                     
  4824.                 theWindow = GetWindowPtrOfNthWindow(index);
  4825.             }
  4826.             
  4827.         if (myErr == noErr)
  4828.             myErr = AECreateDesc(typeMyWndw, (Ptr)&theWindow, sizeof(theWindow), value);
  4829.                 
  4830.         return(myErr);
  4831.     }    /* WindowFromNullAccessor */
  4832.  
  4833. pascal OSErr ApplicationFromNullAccessor(DescType      wantClass,
  4834.                                                                                  const AEDesc  *container,
  4835.                                                                                  DescType      containerClass,
  4836.                                                                                  DescType      form, 
  4837.                                                                                  const AEDesc  *selectionData,
  4838.                                                                                  AEDesc        *value,
  4839.                                                                                  long          theRefCon)
  4840.     {
  4841. #pragma unused (container,selectionData,theRefCon)
  4842.  
  4843.         OSErr    myErr;
  4844.         appToken theApp;
  4845.         AEDesc   resultDesc;
  4846.         
  4847.         value->dataHandle     = nil;
  4848.         resultDesc.dataHandle = nil;
  4849.         
  4850.         /* 
  4851.             should only be called with wantClass = cWindow and
  4852.             with containerClass = typeNull.
  4853.             Currently accept as either formName or formAbsolutePosition
  4854.         */
  4855.         
  4856.         if ((wantClass != cApplication) || (containerClass != typeNull) ||
  4857.               !((form == formName) || (form == formAbsolutePosition)))
  4858.             return(errAEWrongDataType);
  4859.         
  4860.         if ((form == formName) || (form == formAbsolutePosition))
  4861.             {
  4862.                 theApp.highLongOfPSN = 0;
  4863.                 theApp.lowLongOfPSN  = kCurrentProcess;
  4864.             }
  4865.             
  4866.         myErr = AECreateDesc(typeMyAppl, (Ptr)&theApp, sizeof(theApp), value);
  4867.                 
  4868.         return(myErr);
  4869.     }    /* ApplicationFromNullAccessor */
  4870.  
  4871. pascal void MoveToNonSpace(short *start, short limit, charsHandle myChars)
  4872.     /*
  4873.         Treats space,comma, full stop, ; and : as space chars
  4874.     */
  4875.     { 
  4876.         short x;
  4877.  
  4878.         while (*start<=limit) {
  4879.           x = (**myChars)[*start];
  4880.             if ( x == ' ' ||
  4881.                  x == ',' ||
  4882.                  x == '.' ||
  4883.                  x == ',' ||
  4884.                  x == ':' ||
  4885.                  x == 10  ||
  4886.                  x == 13 )
  4887.                 (*start) +=1;
  4888.             else
  4889.                 return;
  4890.         }
  4891.     }
  4892.     
  4893. pascal void MoveToSpace(short *start, short limit, charsHandle myChars)
  4894.     /*
  4895.         Treats space,comma, full stop, ; and : as space chars
  4896.     */
  4897.     { 
  4898.       short x;
  4899.         
  4900.         while (*start<=limit) {
  4901.           x = (**myChars)[*start];
  4902.             if ( x != ' ' &&
  4903.                  x != ',' &&
  4904.                  x != '.' &&
  4905.                  x != ',' &&
  4906.                  x != ':' &&
  4907.                  x != 10  &&
  4908.                  x != 13 )
  4909.                 (*start) +=1;
  4910.             else
  4911.                 return;
  4912.         }
  4913.     }
  4914.  
  4915. pascal short CountWords(TEHandle inTextHandle, short startAt, short forHowManyChars)
  4916.     {
  4917.         charsHandle myChars;
  4918.         short       start;
  4919.         short       limit;
  4920.         short       myWords;
  4921.             
  4922.         myChars  = (charsHandle)(**inTextHandle).hText;
  4923.         limit    = startAt+forHowManyChars-1;
  4924.         start    = startAt;
  4925.         myWords  = 0;
  4926.         MoveToNonSpace(&start, limit, myChars);
  4927.         while (start<=limit) {
  4928.                 myWords++;
  4929.                 MoveToSpace(&start, limit, myChars);
  4930.                 MoveToNonSpace(&start, limit, myChars);
  4931.             }
  4932.         return(myWords);
  4933.     } /* CountWords */
  4934.     
  4935. pascal void GetNthWordInfo(short    whichWord,
  4936.                                                    TEHandle inTextHandle,
  4937.                                                    short    *wordStartChar,
  4938.                                                    short    *wordLength)
  4939.     /*
  4940.         On entry:    wordStartChar is start of char range to count in
  4941.                             wordLength is number of chars to consider
  4942.                             
  4943.         On Exit : wordStartChar is start of requested word
  4944.                             wordLength is number of chars in word
  4945.     */
  4946.     {
  4947.         charsHandle myChars;
  4948.         short       start;
  4949.         short       limit;
  4950.             
  4951.         myChars  = (charsHandle)(**inTextHandle).hText;
  4952.         limit    = *wordStartChar + *wordLength-1;
  4953.         start    = *wordStartChar;
  4954.         MoveToNonSpace(&start, limit, myChars);
  4955.         while ((start<=limit) && (whichWord>0)) {
  4956.  
  4957.                 whichWord       = whichWord-1;
  4958.                 *wordStartChar  = start;
  4959.                 MoveToSpace(&start, limit, myChars);
  4960.                 *wordLength     = start- *wordStartChar;
  4961.                     
  4962.                 MoveToNonSpace(&start, limit, myChars);
  4963.             }
  4964.     } /* GetNthWordInfo */
  4965.     
  4966. pascal void GetWordInfo(short    whichWord,
  4967.                                               TEHandle inTextHandle,
  4968.                                               short    *wordStartChar,
  4969.                                               short    *wordLength)
  4970.     /*
  4971.         On wordStartChar entry is start of char range to count in
  4972.                             wordLength is number of chars to consider
  4973.                             
  4974.         On Exit : wordStartChar is start of requested word
  4975.                             wordLength is number of chars in word
  4976.     */
  4977.     {
  4978.         short noOfWords;
  4979.                     
  4980.         noOfWords = CountWords(inTextHandle, *wordStartChar, *wordLength);
  4981.         
  4982.         if (whichWord<0)
  4983.             whichWord = noOfWords + whichWord + 1;
  4984.             
  4985.         if (whichWord>noOfWords)
  4986.             {
  4987.                 *wordStartChar = *wordStartChar+*wordLength;
  4988.                 *wordLength    = 0;
  4989.             }
  4990.         else
  4991.             GetNthWordInfo(whichWord, inTextHandle, wordStartChar, wordLength);
  4992.     }
  4993.     
  4994. pascal short CountLines(TEHandle inTextHandle)
  4995.     {
  4996.         /*
  4997.             CountLines makes use of info in TERec
  4998.         */
  4999.         return((**inTextHandle).nLines);
  5000.     }
  5001.     
  5002. pascal short LineOfOffset(TEHandle theHTE, short charOffset)
  5003.     {
  5004.         short n;
  5005.     
  5006.         n = (**theHTE).nLines;
  5007.         
  5008.         while (((**theHTE).lineStarts[n-1]>charOffset) &&
  5009.                      (n>0))
  5010.              n--;
  5011.             
  5012.         return(n);
  5013.     } /* LineOfOffset */
  5014.  
  5015. pascal void GetLineInfo(short    whichLine,
  5016.                                                 TEHandle inTextHandle,
  5017.                                               short    *lineStartChar,
  5018.                                               short    *lineLength)
  5019.     {
  5020.         short       noOfLines;
  5021.         charsHandle myChars;
  5022.         
  5023.         /* Addition of lines within text object */
  5024.         short       lineOfStart;
  5025.         short       lineOfEnd;
  5026.         
  5027.         lineOfStart = LineOfOffset(inTextHandle, *lineStartChar);
  5028.         lineOfEnd   = LineOfOffset(inTextHandle, *lineStartChar+*lineLength-1);
  5029.             
  5030.         myChars   = (charsHandle)(**inTextHandle).hText;
  5031.         noOfLines = lineOfEnd - lineOfStart + 1;
  5032.         
  5033.         if (whichLine<0)
  5034.             whichLine = noOfLines + whichLine + 1;
  5035.             
  5036.         noOfLines = CountLines(inTextHandle);
  5037.         whichLine = whichLine + lineOfStart - 1; /* convert offset relative to offset absolute */
  5038.         
  5039.         /* End of addition */
  5040.         
  5041.         if (whichLine<=lineOfEnd)
  5042.             {
  5043.                 *lineStartChar = (**inTextHandle).lineStarts[whichLine-1];
  5044.                 if (whichLine==noOfLines)
  5045.                     *lineLength  = (**inTextHandle).teLength;
  5046.                 else
  5047.                     *lineLength  = (**inTextHandle).lineStarts[whichLine];
  5048.                 *lineLength    = *lineLength-*lineStartChar;
  5049.                 /*
  5050.                     Don't return CR
  5051.                 */
  5052.                 if ((**myChars)[ *lineStartChar+*lineLength-1] == 13)
  5053.                     *lineLength = *lineLength-1;
  5054.             }
  5055.         else
  5056.             {
  5057.                 if (whichLine<noOfLines)
  5058.                   *lineStartChar = (**inTextHandle).lineStarts[whichLine]; /* start of whichLine++ */
  5059.                 else
  5060.                     *lineStartChar = (**inTextHandle).teLength;
  5061.                 *lineLength    = 0;
  5062.             }
  5063.     } /* GetLineInfo */
  5064.     
  5065. pascal OSErr TextElemFromWndwAccessor(DescType     wantClass,
  5066.                                                                         const AEDesc *container,
  5067.                                                                         DescType     containerClass,
  5068.                                                                         DescType     form,
  5069.                                                                         const AEDesc *selectionData,
  5070.                                                                         AEDesc       *value,
  5071.                                                                             long         theRefCon)
  5072.   { 
  5073. #pragma unused (theRefCon)
  5074.     
  5075.         OSErr       myErr;
  5076.         OSErr       ignoreErr;
  5077.         WindowToken theWindow;
  5078.         Size        actSize;
  5079.         long        index;
  5080.         TextToken   theTextToken;
  5081.         AERecord    selectionRecord;
  5082.         TextToken   startText;
  5083.         TextToken   stopText;
  5084.         DescType    returnedType;
  5085.         AEDesc      windDesc;
  5086.         TEHandle    theHTE;
  5087.         DPtr        theDocument;
  5088.         short       wordStartChar;
  5089.         short       wordLength;
  5090.     
  5091.         myErr = -1700;    /* or whatever */
  5092.         
  5093.         selectionRecord.dataHandle = nil;
  5094.         
  5095.         /* do some checking for robustness' sake */
  5096.         
  5097.         if ((containerClass != cWindow) ||
  5098.               ((wantClass != cChar) && 
  5099.                  (wantClass != cSpot) && 
  5100.                  (wantClass != cWord) &&
  5101.                  (wantClass != cLine)    ) ||
  5102.               ((form!=formRange) && (form!=formAbsolutePosition)))
  5103.             return(errAEWrongDataType);
  5104.             
  5105.         /* let's get the window which contains the text element */
  5106.         
  5107.         myErr = AECoerceDesc(container, typeMyWndw, &windDesc);
  5108.         GetRawDataFromDescriptor(    &windDesc,
  5109.                                                             (Ptr)&theWindow,
  5110.                                                             sizeof(theWindow),
  5111.                                                             &actSize);
  5112.         ignoreErr = AEDisposeDesc(&windDesc);
  5113.                                                             
  5114.         if (theWindow==nil)
  5115.             myErr = errAEIllegalIndex;
  5116.         else
  5117.             {
  5118.                                                                                     
  5119.                 theTextToken.tokenWindow = theWindow;
  5120.                 
  5121.                 theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  5122.                 theHTE      = theDocument->theText;
  5123.                 
  5124.                 if (form == formAbsolutePosition)
  5125.                     {
  5126.                         myErr = GetLongIntFromDescriptor(selectionData, &index);
  5127.                         
  5128.                         if (wantClass==cSpot)
  5129.                             {
  5130.                               if (index<0)
  5131.                                     theTextToken.tokenOffset = (**theHTE).teLength+index+2; /* Past last char */
  5132.                                 else
  5133.                                     theTextToken.tokenOffset = index;
  5134.                                     
  5135.                                 theTextToken.tokenLength = 0;
  5136.                             }
  5137.                             
  5138.                         if (wantClass==cChar)
  5139.                             {
  5140.                                 if (index<0)
  5141.                                     theTextToken.tokenOffset = (**theHTE).teLength+index+1;
  5142.                                 else
  5143.                                   theTextToken.tokenOffset = index;
  5144.                                     
  5145.                                 theTextToken.tokenLength = 1;
  5146.                             }
  5147.                         
  5148.                         if (wantClass==cWord)
  5149.                             {
  5150.                                 wordStartChar = 0;
  5151.                                 wordLength    = (**theHTE).teLength;
  5152.                                 GetWordInfo(index, theHTE, &wordStartChar, &wordLength); /* zero based */
  5153.                                 theTextToken.tokenOffset = wordStartChar+1;
  5154.                                 theTextToken.tokenLength = wordLength;
  5155.                             }
  5156.                             
  5157.                         if (wantClass==cLine)
  5158.                             {
  5159.                                 wordStartChar = 0;
  5160.                                 wordLength    = (**theHTE).teLength;
  5161.                                 GetLineInfo(index, theHTE, &wordStartChar, &wordLength); /* zero based */
  5162.                                 theTextToken.tokenOffset = wordStartChar+1;
  5163.                                 theTextToken.tokenLength = wordLength;
  5164.                             }
  5165.                     }    /* of formAbsolutePosition */
  5166.                 
  5167.                 if (form == formRange)
  5168.                     {
  5169.                         /* coerce the selection data into an AERecord */
  5170.                         
  5171.                          myErr = AECoerceDesc(selectionData, typeAERecord, &selectionRecord);
  5172.                         
  5173.                         /* get the start object as a text token - 
  5174.                                 this will reenter this proc but as formAbsolutePosition via the coercion handler*/
  5175.                         
  5176.                         myErr =  AEGetKeyPtr(&selectionRecord,
  5177.                                                                  keyAERangeStart,
  5178.                                                                  typeMyText,
  5179.                                                                  &returnedType,
  5180.                                                                  (Ptr)&startText,
  5181.                                                                  sizeof(startText),
  5182.                                                                  &actSize);
  5183.                         
  5184.                         /* now do the same for the stop object */
  5185.                         
  5186.                         if (myErr==noErr)
  5187.                             myErr =  AEGetKeyPtr(&selectionRecord,
  5188.                                                                      keyAERangeStop,
  5189.                                                                      typeMyText,
  5190.                                                                      &returnedType,
  5191.                                                                      (Ptr)&stopText,
  5192.                                                                      sizeof(stopText),
  5193.                                                                      &actSize);
  5194.                         
  5195.                         if (myErr==noErr)
  5196.                             if ((theTextToken.tokenWindow != stopText.tokenWindow) ||
  5197.                                   (theTextToken.tokenWindow != startText.tokenWindow))
  5198.                                 myErr = errAECorruptData;    /* or whatever ????*/
  5199.                             
  5200.                         theTextToken.tokenOffset  = startText.tokenOffset;            
  5201.                         theTextToken.tokenLength  = stopText.tokenOffset +
  5202.                                                                                  stopText.tokenLength - 
  5203.                                                                                  startText.tokenOffset;
  5204.                                                                                  
  5205.                         if (theTextToken.tokenLength<0)
  5206.                             myErr = errAECorruptData;    /* or whatever */
  5207.                                                                              
  5208.                         ignoreErr = AEDisposeDesc(&selectionRecord);
  5209.                         
  5210.                     }    /* of formRange */
  5211.             }
  5212.         
  5213.         /* return theTextToken in a descriptor */
  5214.         
  5215.         if (myErr==noErr)
  5216.             myErr = AECreateDesc(typeMyText,
  5217.                                                      (Ptr)&theTextToken,
  5218.                                                      sizeof(theTextToken),
  5219.                                                      value);
  5220.                 
  5221.         return(myErr);
  5222.     }    /* TextElemFromWndwAccessor */
  5223.  
  5224. pascal OSErr TextElemFromTextAccessor(DescType     wantClass,
  5225.                                                                         const AEDesc *container,
  5226.                                                                         DescType     containerClass,
  5227.                                                                         DescType     form,
  5228.                                                                         const AEDesc *selectionData,
  5229.                                                                         AEDesc       *value,
  5230.                                                                         long         theRefCon)
  5231.     { 
  5232. #pragma unused (theRefCon, containerClass)
  5233.  
  5234.         OSErr       myErr;
  5235.         OSErr       ignoreErr;
  5236.         Size        actSize;
  5237.         long        index;
  5238.         TextToken   theTextToken;
  5239.         AERecord    selectionRecord;
  5240.         TextToken   startText;
  5241.         TextToken   stopText;
  5242.         DescType    returnedType;
  5243.         AEDesc      textDesc;
  5244.         TEHandle    theHTE;
  5245.         short       wordStartChar;
  5246.         short       wordLength;
  5247.         DPtr        theDocument;
  5248.     
  5249.         myErr = -1700;    /* or whatever */
  5250.             
  5251.         /* do some checking for robustness' sake */
  5252.         
  5253.         if (((wantClass != cChar) && 
  5254.                  (wantClass != cSpot) && 
  5255.                  (wantClass != cLine) && 
  5256.                  (wantClass != cWord)) ||
  5257.               ((form != formAbsolutePosition) && (form != formRange)))
  5258.             return(errAEWrongDataType);
  5259.         
  5260.         /* let's get the src text */
  5261.         
  5262.         myErr = AECoerceDesc(container, typeMyText, &textDesc);
  5263.         GetRawDataFromDescriptor(    &textDesc,
  5264.                                                             (Ptr)&theTextToken,
  5265.                                                             sizeof(theTextToken),
  5266.                                                             &actSize);
  5267.                                                             
  5268.         ignoreErr = AEDisposeDesc(&textDesc);
  5269.                                                             
  5270.         theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  5271.         theHTE      = theDocument->theText;
  5272.         
  5273.         if (form == formAbsolutePosition)
  5274.             {
  5275.                 myErr = GetLongIntFromDescriptor(selectionData, &index);
  5276.                 
  5277.                 if (wantClass==cSpot)
  5278.                     {
  5279.                         if (index<0)
  5280.                             theTextToken.tokenOffset = theTextToken.tokenOffset+index+1+theTextToken.tokenLength;
  5281.                         else
  5282.                             theTextToken.tokenOffset = theTextToken.tokenOffset+index-1;
  5283.                         theTextToken.tokenLength = 0;
  5284.                     }
  5285.                     
  5286.                 if (wantClass==cChar)
  5287.                     {
  5288.                         if (index<0)
  5289.                             theTextToken.tokenOffset = theTextToken.tokenOffset+index+1+theTextToken.tokenLength;
  5290.                         else
  5291.                             theTextToken.tokenOffset = theTextToken.tokenOffset+index-1;
  5292.                         theTextToken.tokenLength = 1;
  5293.                     }
  5294.                                     
  5295.                 if (wantClass==cWord)
  5296.                     {
  5297.                         wordStartChar = theTextToken.tokenOffset-1;
  5298.                         wordLength    = theTextToken.tokenLength;
  5299.                         
  5300.                         GetWordInfo(index, theHTE, &wordStartChar, &wordLength);/*zero based*/
  5301.                         
  5302.                         theTextToken.tokenOffset = wordStartChar+1;
  5303.                         theTextToken.tokenLength = wordLength;
  5304.                     }
  5305.                     
  5306.                 if (wantClass==cLine)
  5307.                     {
  5308.                         wordStartChar = theTextToken.tokenOffset-1;
  5309.                         wordLength    = theTextToken.tokenLength;
  5310.                         
  5311.                         GetLineInfo(index, theHTE, &wordStartChar, &wordLength);
  5312.                         
  5313.                         theTextToken.tokenOffset = wordStartChar+1;
  5314.                         theTextToken.tokenLength = wordLength;
  5315.                     }
  5316.     
  5317.             }    /* of formAbsolutePosition */
  5318.         
  5319.         
  5320.         if (form == formRange)
  5321.             {
  5322.                 /* coerce the selection data into an AERecord */
  5323.                 
  5324.                  myErr = AECoerceDesc(selectionData, typeAERecord, &selectionRecord);
  5325.                 
  5326.                 /* get the start object as a text token - 
  5327.                         this will reenter this proc but as formAbsolutePosition via the coercion handler*/
  5328.                 
  5329.                 myErr =  AEGetKeyPtr(&selectionRecord,
  5330.                                                          keyAERangeStart,
  5331.                                                          typeMyText,
  5332.                                                          &returnedType,
  5333.                                                          (Ptr)&startText,
  5334.                                                          sizeof(startText),
  5335.                                                          &actSize);
  5336.                 
  5337.                 /* now do the same for the stop object */
  5338.                 
  5339.                 if (myErr==noErr)
  5340.                     myErr =  AEGetKeyPtr(&selectionRecord,
  5341.                                                              keyAERangeStop,
  5342.                                                              typeMyText,
  5343.                                                              &returnedType,
  5344.                                                              (Ptr)&stopText,
  5345.                                                              sizeof(stopText),
  5346.                                                              &actSize);
  5347.                 
  5348.                 if (myErr==noErr)
  5349.                     if ((theTextToken.tokenWindow != stopText.tokenWindow) ||
  5350.                           (theTextToken.tokenWindow != startText.tokenWindow))
  5351.                         myErr = errAECorruptData;    /* or whatever */
  5352.                     
  5353.                 theTextToken.tokenOffset  = startText.tokenOffset;            
  5354.                 theTextToken.tokenLength  = stopText.tokenOffset +
  5355.                                                                          stopText.tokenLength - 
  5356.                                                                          startText.tokenOffset;
  5357.                                                                      
  5358.                 ignoreErr = AEDisposeDesc(&selectionRecord);
  5359.             }    /* of formRange */
  5360.             
  5361.         /* return theTextToken in a descriptor */
  5362.         
  5363.         myErr = AECreateDesc( typeMyText,
  5364.                                                     (Ptr)&theTextToken,
  5365.                                                     sizeof(theTextToken),
  5366.                                                     value);
  5367.             
  5368.         return(myErr);
  5369.     }    /* TextElemFromTextAccessor */
  5370.  
  5371. pascal OSErr PropertyFromTextAccessor(DescType     wantClass,
  5372.                                                                             const AEDesc *container,
  5373.                                                                             DescType     containerClass,
  5374.                                                                             DescType     form, 
  5375.                                                                             const AEDesc *selectionData,
  5376.                                                                             AEDesc       *value,
  5377.                                                                             long         theRefCon)
  5378.   {
  5379. #pragma unused (theRefCon, containerClass)
  5380.     
  5381.         OSErr         myErr;
  5382.         OSErr         ignoreErr;
  5383.         TextToken     theTextToken;
  5384.         DescType      theProperty;
  5385.         AEDesc        textDesc;
  5386.         AEDesc        propDesc;
  5387.         Size          actualSize;
  5388.         textPropToken myTextProp;
  5389.             
  5390.         value->dataHandle   = nil;
  5391.         textDesc.dataHandle = nil;
  5392.         propDesc.dataHandle = nil;
  5393.         
  5394.         if ((wantClass != cProperty) ||
  5395.                 (form != formPropertyID))
  5396.             {
  5397.                 return(errAEWrongDataType);
  5398.             }
  5399.         
  5400.         /* get the text token */
  5401.         myErr = AECoerceDesc(container, typeMyText, &textDesc);
  5402.         GetRawDataFromDescriptor(    &textDesc,
  5403.                                                             (Ptr)&theTextToken,
  5404.                                                             sizeof(theTextToken),
  5405.                                                             &actualSize);
  5406.                 
  5407.         /* get the property */
  5408.         myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  5409.         GetRawDataFromDescriptor(&propDesc,
  5410.                                                          (Ptr)&theProperty,
  5411.                                                          sizeof(theProperty),
  5412.                                                          &actualSize);
  5413.         /*
  5414.             Combine the two into single token
  5415.         */
  5416.         myTextProp.propertyTextToken = theTextToken;
  5417.         myTextProp.propertyProperty  = theProperty;
  5418.         
  5419.         myErr = AECreateDesc(typeMyTextProp,
  5420.                                                  (Ptr)&myTextProp,
  5421.                                                  sizeof(myTextProp),
  5422.                                                  value);
  5423.             
  5424.         if (textDesc.dataHandle)
  5425.             ignoreErr = AEDisposeDesc(&textDesc);
  5426.             
  5427.         if (propDesc.dataHandle)
  5428.             ignoreErr = AEDisposeDesc(&propDesc);
  5429.             
  5430.         return(myErr);
  5431. }    /* PropertyFromTextAccessor */
  5432.  
  5433. pascal OSErr PropertyFromWndwAccessor(DescType     wantClass,
  5434.                                                                         const AEDesc *container,
  5435.                                                                         DescType     containerClass,
  5436.                                                                         DescType     form, 
  5437.                                                                         const AEDesc *selectionData,
  5438.                                                                         AEDesc       *value,
  5439.                                                                         long         theRefCon)
  5440.   { 
  5441. #pragma unused (theRefCon, containerClass)
  5442.     
  5443.         OSErr           myErr;
  5444.         OSErr           ignoreErr;
  5445.         WindowToken     theWindowToken;
  5446.         DescType        theProperty;
  5447.         AEDesc          windowDesc;
  5448.         AEDesc          propDesc;
  5449.         Size            actualSize;
  5450.         windowPropToken myWindowProp;
  5451.         
  5452.         value->dataHandle     = nil;
  5453.         windowDesc.dataHandle = nil;
  5454.         propDesc.dataHandle   = nil;
  5455.         
  5456.         if ((wantClass != cProperty) ||
  5457.               (form != formPropertyID))
  5458.             {
  5459.                 return(errAEWrongDataType);
  5460.             }
  5461.         
  5462.         /* get the window token - it's the container */
  5463.         
  5464.         myErr = AECoerceDesc(container, typeMyWndw, &windowDesc);
  5465.         GetRawDataFromDescriptor(    &windowDesc,
  5466.                                                             (Ptr)&theWindowToken,
  5467.                                                             sizeof(theWindowToken),
  5468.                                                             &actualSize);
  5469.                                                             
  5470.         /* Check the window exists */
  5471.         
  5472.         if (theWindowToken==nil)
  5473.             myErr = errAEIllegalIndex;
  5474.         else
  5475.             {
  5476.             
  5477.                 /* get the property - it's in the selection data */
  5478.                 
  5479.                 myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  5480.                 GetRawDataFromDescriptor(    &propDesc,
  5481.                                                                     (Ptr)&theProperty,
  5482.                                                                     sizeof(theProperty),
  5483.                                                                     &actualSize);
  5484.                 /*
  5485.                     Combine the two into single token
  5486.                 */
  5487.                 myWindowProp.tokenWindowToken = theWindowToken;
  5488.                 myWindowProp.tokenProperty    = theProperty;
  5489.                 
  5490.                 myErr = AECreateDesc( typeMyWindowProp,
  5491.                                                             (Ptr)&myWindowProp,
  5492.                                                             sizeof(myWindowProp),
  5493.                                                             value);
  5494.             }
  5495.             
  5496.         if (windowDesc.dataHandle)
  5497.             ignoreErr = AEDisposeDesc(&windowDesc);
  5498.             
  5499.         if (propDesc.dataHandle)
  5500.             ignoreErr = AEDisposeDesc(&propDesc);
  5501.             
  5502.         return(myErr);
  5503.   }    /* PropertyFromWndwAccessor */
  5504.  
  5505.  
  5506. pascal OSErr PropertyFromWinPropertyAccessor(DescType     wantClass,
  5507.                                                                                        const AEDesc *container,
  5508.                                                                                        DescType     containerClass,
  5509.                                                                                        DescType     form,
  5510.                                                                                        const AEDesc *selectionData,
  5511.                                                                                        AEDesc       *value,
  5512.                                                                                        long         theRefCon)
  5513. {
  5514. #pragma unused (theRefCon, containerClass)
  5515.  
  5516.    OSErr           myErr;
  5517.    OSErr           ignoreErr;
  5518.    windowPropToken theWindowPropToken;
  5519.    AEDesc          newDesc, propDesc;
  5520.    Size            tokenSize;
  5521.    DPtr            theDocument;
  5522.    TextToken       theTextToken;
  5523.    DescType        theProperty;
  5524.    Size            actualSize;
  5525.    textPropToken   myTextProp;
  5526.  
  5527.         value->dataHandle     = nil;
  5528.         propDesc.dataHandle   = nil;
  5529.  
  5530.         if ((wantClass != formPropertyID) || (form != formPropertyID))
  5531.         {
  5532.             return(errAEWrongDataType);
  5533.         }
  5534.  
  5535.    /* the container is a window property token. Get the token for this */
  5536.    /* and check that it is valid to get a property of this property */
  5537.  
  5538.         myErr = AECoerceDesc(container, typeMyWindowProp, &newDesc);
  5539.         
  5540.         if (myErr)
  5541.             return(myErr);
  5542.  
  5543.         GetRawDataFromDescriptor(&newDesc,
  5544.                                                         (Ptr)&theWindowPropToken,
  5545.                                                         sizeof(theWindowPropToken),
  5546.                                                         &tokenSize);
  5547.  
  5548.            /* if the property is pSelection, we then want to convert this to a text token */
  5549.            /* and then return a text property token */
  5550.  
  5551.         if (theWindowPropToken.tokenProperty == pSelection)
  5552.         {
  5553.             /* now get the property- it's in the selection data */
  5554.             myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  5555.             GetRawDataFromDescriptor(&propDesc,
  5556.                                                             (Ptr)&theProperty,
  5557.                                                             sizeof(theProperty),
  5558.                                                             &actualSize);
  5559.  
  5560.             if (pContents == theProperty)
  5561.             {
  5562.                 theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  5563.                 
  5564.                 /* build a text token to represent the selection */
  5565.                 theTextToken.tokenOffset = (**(theDocument->theText)).selStart + 1;
  5566.                 theTextToken.tokenLength = ((**(theDocument->theText)).selEnd -
  5567.                                         (**(theDocument->theText)).selStart);
  5568.                 theTextToken.tokenWindow = theWindowPropToken.tokenWindowToken;
  5569.                 
  5570.                 /* Combine the two into single token */
  5571.                 myTextProp.propertyTextToken = theTextToken;
  5572.                 myTextProp.propertyProperty  = theProperty;
  5573.                 
  5574.                 myErr = AECreateDesc(typeMyTextProp,(Ptr)&myTextProp,sizeof(myTextProp),value);
  5575.             }
  5576.             else
  5577.                 myErr = errAEWrongDataType;
  5578.             
  5579.             if (propDesc.dataHandle) ignoreErr = AEDisposeDesc(&propDesc);
  5580.             if (newDesc.dataHandle)  ignoreErr = AEDisposeDesc(&newDesc);
  5581.             
  5582.             return myErr;
  5583.         }
  5584.  
  5585.         if (newDesc.dataHandle)  ignoreErr = AEDisposeDesc(&newDesc);
  5586.  
  5587.         return errAEWrongDataType;
  5588. }
  5589.  
  5590.  
  5591. pascal OSErr PropertyFromApplAccessor(DescType     wantClass,
  5592.                                                                             const AEDesc *container,
  5593.                                                                             DescType     containerClass,
  5594.                                                                             DescType     form, 
  5595.                                                                             const AEDesc *selectionData,
  5596.                                                                             AEDesc       *value,
  5597.                                                                             long         theRefCon)
  5598.   {
  5599. #pragma unused (theRefCon, containerClass)
  5600.     
  5601.         OSErr         myErr;
  5602.         OSErr         ignoreErr;
  5603.         appToken      theApplToken;
  5604.         DescType      theProperty;
  5605.         AEDesc        applDesc;
  5606.         AEDesc        propDesc;
  5607.         Size          actualSize;
  5608.         applPropToken myApplProp;
  5609.             
  5610.         value->dataHandle     = nil;
  5611.         applDesc.dataHandle   = nil;
  5612.         propDesc.dataHandle   = nil;
  5613.         
  5614.         if ((wantClass != cProperty) ||
  5615.               (form != formPropertyID))
  5616.             {
  5617.                 return(errAEWrongDataType);
  5618.             }
  5619.         
  5620.         /* get the application token - it's the container */
  5621.         
  5622.         myErr = AECoerceDesc(container, typeMyAppl, &applDesc);
  5623.         GetRawDataFromDescriptor(&applDesc,
  5624.                                                          (Ptr)&theApplToken,
  5625.                                                          sizeof(theApplToken),
  5626.                                                          &actualSize);
  5627.                 
  5628.         /* get the property - it's in the selection data */
  5629.         
  5630.         myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  5631.         GetRawDataFromDescriptor(&propDesc,
  5632.                                                          (Ptr)&theProperty,
  5633.                                                          sizeof(theProperty),
  5634.                                                          &actualSize);
  5635.         /*
  5636.             Combine the two into single token
  5637.         */
  5638.         myApplProp.tokenApplToken    = theApplToken;
  5639.         myApplProp.tokenApplProperty = theProperty;
  5640.         
  5641.         myErr = AECreateDesc(typeMyApplProp,
  5642.                                                  (Ptr)&myApplProp,
  5643.                                                  sizeof(myApplProp),
  5644.                                                  value);
  5645.             
  5646.         if (applDesc.dataHandle)
  5647.             ignoreErr = AEDisposeDesc(&applDesc);
  5648.             
  5649.         if (propDesc.dataHandle)
  5650.             ignoreErr = AEDisposeDesc(&propDesc);
  5651.             
  5652.         return(myErr);
  5653. }    /* PropertyFromApplAccessor */
  5654.  
  5655. pascal OSErr MenuNameToMenuToken(const Str255 theName, MenuToken *theToken)
  5656.     {
  5657.         short   index;
  5658.         
  5659.         for (index=appleM; index<=kLastMenu; index++)
  5660.          {
  5661.                 if (IUEqualString(theName, (**(myMenus[index])).menuData)==0)
  5662.                   {
  5663.                         theToken->theTokenMenu = myMenus[index];
  5664.                         theToken->theTokenID   = index+appleID;
  5665.                         return(noErr);
  5666.                     }
  5667.          }
  5668.         return(errAEIllegalIndex);
  5669.     }
  5670.  
  5671. pascal OSErr MenuFromNullAccessor(DescType      wantClass,
  5672.                                                                     const AEDesc  *container,
  5673.                                                                     DescType      containerClass,
  5674.                                                                     DescType      form, 
  5675.                                                                     const AEDesc  *selectionData,
  5676.                                                                     AEDesc        *value,
  5677.                                                                     long          theRefCon)
  5678.     {
  5679. #pragma unused (container,theRefCon)
  5680.     
  5681.         OSErr       myErr;
  5682.         Str255      nameStr;
  5683.         MenuToken   theMenu;
  5684.         short       index;
  5685.         AEDesc      resultDesc;
  5686.         
  5687.         myErr = errAEBadKeyForm;    /* or whatever */
  5688.         
  5689.         value->dataHandle     = nil;
  5690.         resultDesc.dataHandle = nil;
  5691.         
  5692.         /* 
  5693.             should only be called with wantClass = cMenu and
  5694.             with containerClass = typeNull or typeMyAppl.
  5695.             Currently accept as either formName or formAbsolutePosition
  5696.         */
  5697.         
  5698.         if ((wantClass != cMenu) || 
  5699.               ((containerClass != typeNull) && (containerClass != typeMyAppl)) ||
  5700.                !((form == formName) || (form == formAbsolutePosition)))
  5701.             return(errAEWrongDataType);
  5702.         
  5703.         if (form == formName)
  5704.             {
  5705.                 myErr = GetPStringFromDescriptor(selectionData, (char *)nameStr);
  5706.                 myErr = MenuNameToMenuToken(nameStr, &theMenu);
  5707.             }
  5708.         
  5709.         if (form == formAbsolutePosition)
  5710.             {
  5711.                 myErr     = GetIntegerFromDescriptor(selectionData, &index);
  5712.                 if (index<0)
  5713.                     index = kLastMenu + index + 1;
  5714.                     
  5715.                 if (index>0 && index<=kLastMenu+1)
  5716.                     {
  5717.                         theMenu.theTokenMenu = myMenus[index-1];
  5718.                         theMenu.theTokenID   = index-1+appleID;
  5719.                     }
  5720.                 else
  5721.               myErr = errAEIllegalIndex;    /* or whatever */
  5722.             }
  5723.             
  5724.         if (myErr == noErr)
  5725.             myErr = AECreateDesc(typeMyMenu, (Ptr)&theMenu, sizeof(theMenu), value);
  5726.                 
  5727.         return(myErr);
  5728.     }    /* MenuFromNullAccessor */
  5729.  
  5730. pascal OSErr PropertyFromMenuAccessor(DescType     wantClass,
  5731.                                                                             const AEDesc *container,
  5732.                                                                             DescType     containerClass,
  5733.                                                                             DescType     form, 
  5734.                                                                             const AEDesc *selectionData,
  5735.                                                                             AEDesc       *value,
  5736.                                                                             long         theRefCon)
  5737.   {
  5738. #pragma unused (theRefCon, containerClass)
  5739.     
  5740.         OSErr         myErr;
  5741.         OSErr         ignoreErr;
  5742.         MenuToken     theMenuToken;
  5743.         DescType      theProperty;
  5744.         AEDesc        menuDesc;
  5745.         AEDesc        propDesc;
  5746.         Size          actualSize;
  5747.         MenuPropToken myMenuProp;
  5748.             
  5749.         value->dataHandle     = nil;
  5750.         menuDesc.dataHandle   = nil;
  5751.         propDesc.dataHandle   = nil;
  5752.         
  5753.         if ((wantClass != cProperty) ||
  5754.               (form != formPropertyID))
  5755.             {
  5756.                 return(errAEWrongDataType);
  5757.             }
  5758.         
  5759.         /* get the menu token - it's the container */
  5760.         
  5761.         myErr = AECoerceDesc(container, typeMyMenu, &menuDesc);
  5762.         GetRawDataFromDescriptor(&menuDesc,
  5763.                                                          (Ptr)&theMenuToken,
  5764.                                                          sizeof(theMenuToken),
  5765.                                                          &actualSize);
  5766.                 
  5767.         /* get the property - it's in the selection data */
  5768.         
  5769.         myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  5770.         GetRawDataFromDescriptor(&propDesc,
  5771.                                                          (Ptr)&theProperty,
  5772.                                                          sizeof(theProperty),
  5773.                                                          &actualSize);
  5774.         /*
  5775.             Combine the two into single token
  5776.         */
  5777.         myMenuProp.theMenuToken = theMenuToken;
  5778.         myMenuProp.theMenuProp  = theProperty;
  5779.         
  5780.         myErr = AECreateDesc(typeMyMenuProp,
  5781.                                                  (Ptr)&myMenuProp,
  5782.                                                  sizeof(myMenuProp),
  5783.                                                  value);
  5784.             
  5785.         if (menuDesc.dataHandle)
  5786.             ignoreErr = AEDisposeDesc(&menuDesc);
  5787.             
  5788.         if (propDesc.dataHandle)
  5789.             ignoreErr = AEDisposeDesc(&propDesc);
  5790.             
  5791.         return(myErr);
  5792. }    /* PropertyFromMenuAccessor */
  5793.  
  5794. pascal OSErr PropertyFromMenuItemAccessor(DescType     wantClass,
  5795.                                                                                     const AEDesc *container,
  5796.                                                                                     DescType     containerClass,
  5797.                                                                                     DescType     form, 
  5798.                                                                                     const AEDesc *selectionData,
  5799.                                                                                     AEDesc       *value,
  5800.                                                                                     long         theRefCon)
  5801.   {
  5802. #pragma unused (theRefCon, containerClass)
  5803.     
  5804.         OSErr         myErr;
  5805.         OSErr         ignoreErr;
  5806.         MenuItemToken theMenuItemToken;
  5807.         DescType      theProperty;
  5808.         AEDesc        itemDesc;
  5809.         AEDesc        propDesc;
  5810.         Size          actualSize;
  5811.         MenuItemPropToken myItemProp;
  5812.             
  5813.         value->dataHandle     = nil;
  5814.         itemDesc.dataHandle   = nil;
  5815.         propDesc.dataHandle   = nil;
  5816.         
  5817.         if ((wantClass != cProperty) ||
  5818.               (form != formPropertyID))
  5819.             {
  5820.                 return(errAEWrongDataType);
  5821.             }
  5822.         
  5823.         /* get the menu token - it's the container */
  5824.         
  5825.         myErr = AECoerceDesc(container, typeMyMenuItem, &itemDesc);
  5826.         GetRawDataFromDescriptor(&itemDesc,
  5827.                                                          (Ptr)&theMenuItemToken,
  5828.                                                          sizeof(theMenuItemToken),
  5829.                                                          &actualSize);
  5830.                 
  5831.         /* get the property - it's in the selection data */
  5832.         
  5833.         myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  5834.         GetRawDataFromDescriptor(&propDesc,
  5835.                                                          (Ptr)&theProperty,
  5836.                                                          sizeof(theProperty),
  5837.                                                          &actualSize);
  5838.         /*
  5839.             Combine the two into single token
  5840.         */
  5841.         myItemProp.theItemToken  = theMenuItemToken;
  5842.         myItemProp.theItemProp   = theProperty;
  5843.         
  5844.         myErr = AECreateDesc(typeMyItemProp,
  5845.                                                  (Ptr)&myItemProp,
  5846.                                                  sizeof(myItemProp),
  5847.                                                  value);
  5848.             
  5849.         if (itemDesc.dataHandle)
  5850.             ignoreErr = AEDisposeDesc(&itemDesc);
  5851.             
  5852.         if (propDesc.dataHandle)
  5853.             ignoreErr = AEDisposeDesc(&propDesc);
  5854.             
  5855.         return(myErr);
  5856. }    /* PropertyFromMenuItemAccessor */
  5857.  
  5858. pascal OSErr ItemNameToItemIndex(const Str255 theName, MenuHandle theMenu, short *theIndex)
  5859.     {
  5860.         short   index;
  5861.         short   maxItems;
  5862.         Str255  menuName;
  5863.         
  5864.         maxItems = CountMItems(theMenu);
  5865.         
  5866.         for (index=1; index<=maxItems; index++)
  5867.             {
  5868.                 GetItem(theMenu, index, menuName);
  5869.                 if (IUEqualString(theName, menuName)==0)
  5870.                     {
  5871.                         *theIndex = index;
  5872.                         return(noErr);
  5873.                     }
  5874.             }
  5875.         return(errAEIllegalIndex);
  5876.     }
  5877.     
  5878. pascal OSErr MenuItemFromMenuAccessor(DescType     wantClass,
  5879.                                                                             const AEDesc *container,
  5880.                                                                             DescType     containerClass,
  5881.                                                                             DescType     form, 
  5882.                                                                             const AEDesc *selectionData,
  5883.                                                                             AEDesc       *value,
  5884.                                                                             long         theRefCon)
  5885.   {
  5886. #pragma unused (theRefCon)
  5887.     
  5888.         OSErr         myErr;
  5889.         OSErr         ignoreErr;
  5890.         MenuItemToken theMenuItemToken;
  5891.         MenuToken     theMenuToken;
  5892.         AEDesc        menuDesc;
  5893.         Size          actualSize;
  5894.         Str255        nameStr;
  5895.         short         maxItems;
  5896.         short         index;
  5897.             
  5898.         value->dataHandle     = nil;
  5899.         menuDesc.dataHandle   = nil;
  5900.         
  5901.         if ((wantClass != cMenuItem) || (containerClass != cMenu) ||
  5902.               ((form != formAbsolutePosition) && (form != formName)))
  5903.             {
  5904.                 return(errAEWrongDataType);
  5905.             }
  5906.         
  5907.         /* get the menu token - it's the container */
  5908.         
  5909.         myErr = AECoerceDesc(container, typeMyMenu, &menuDesc);
  5910.         GetRawDataFromDescriptor(&menuDesc,
  5911.                                                          (Ptr)&theMenuToken,
  5912.                                                          sizeof(theMenuToken),
  5913.                                                          &actualSize);
  5914.                 
  5915.         if (form==formAbsolutePosition)
  5916.             {
  5917.                 myErr = GetIntegerFromDescriptor(selectionData, &index);
  5918.                 maxItems = CountMItems(theMenuToken.theTokenMenu);
  5919.                 
  5920.                 if (index<0)
  5921.                     index = maxItems + index + 1;
  5922.                     
  5923.                 if ((index<1) || (index>maxItems))
  5924.                   myErr = errAEIllegalIndex;
  5925.             }
  5926.             
  5927.         if (form == formName)
  5928.             {
  5929.                 myErr  = GetPStringFromDescriptor(selectionData, (char *)nameStr);
  5930.                 myErr  = ItemNameToItemIndex(nameStr, theMenuToken.theTokenMenu, &index);
  5931.             }
  5932.         
  5933.         /*
  5934.             Combine the two into single token
  5935.         */
  5936.     
  5937.         theMenuItemToken.theMenuToken  = theMenuToken;
  5938.         theMenuItemToken.theTokenItem  = index;
  5939.         
  5940.         if (myErr==noErr)
  5941.             myErr = AECreateDesc(typeMyMenuItem,
  5942.                                                      (Ptr)&theMenuItemToken,
  5943.                                                      sizeof(theMenuItemToken),
  5944.                                                      value);
  5945.             
  5946.         if (menuDesc.dataHandle)
  5947.             ignoreErr = AEDisposeDesc(&menuDesc);
  5948.             
  5949.         return(myErr);
  5950. }    /* MenuItemFromMenuAccessor */
  5951.  
  5952. /*******************************************************************************/
  5953. /*
  5954.     Stuff for counting objects
  5955. */
  5956.  
  5957. pascal OSErr MyCountProc(DescType     desiredType,
  5958.                                                DescType     containerClass,
  5959.                                                const AEDesc *container,
  5960.                                                long         *result)
  5961.                                             
  5962. /* so far all I count is:
  5963.   (1) the number of active windows in the app;
  5964.   (2) the number of words in a window 
  5965. */
  5966.  
  5967.     {   
  5968.         OSErr       myErr;
  5969.         OSErr       ignoreErr;
  5970.         WindowToken theWindowToken;
  5971.         DPtr        theDocument;
  5972.         TEHandle    theHTE;
  5973.         AEDesc      newDesc;
  5974.         short       wordStart;
  5975.         short       wordLength;
  5976.         Size        tokenSize;
  5977.         TextToken   theTextToken;
  5978.             
  5979.         *result = -1;    /* easily recognized illegal value */
  5980.             
  5981.         myErr = errAEWrongDataType;
  5982.         
  5983.         if (desiredType == cWindow)
  5984.             {
  5985.                 if ((containerClass == typeNull) ||
  5986.                       (containerClass == cApplication))
  5987.                     *result = CountWindows();
  5988.             }
  5989.             
  5990.         if ((desiredType == cWord) ||
  5991.               (desiredType == cLine) ||
  5992.               (desiredType == cChar))
  5993.             {
  5994.                 myErr = AECoerceDesc(container, typeMyWndw, &newDesc);
  5995.                 if (newDesc.descriptorType!=typeNull)
  5996.                     {
  5997.                         GetRawDataFromDescriptor(&newDesc,
  5998.                                                                          (Ptr)&theWindowToken,
  5999.                                                                          sizeof(theWindowToken),
  6000.                                                                          &tokenSize);
  6001.                                                                          
  6002.                         ignoreErr = AEDisposeDesc(&newDesc);
  6003.                                                                          
  6004.                         if (theWindowToken==nil)
  6005.                             myErr = errAEIllegalIndex;
  6006.                         else
  6007.                             {
  6008.                         
  6009.                                 theDocument = DPtrFromWindowPtr(theWindowToken);
  6010.                                 theHTE      = theDocument->theText;
  6011.                                 
  6012.                                 if (desiredType == cWord)
  6013.                                     {
  6014.                                         wordStart   = 0;
  6015.                                         wordLength  = (**theHTE).teLength;
  6016.                                         *result     = CountWords(theHTE, wordStart, wordLength);
  6017.                                     }
  6018.                                 
  6019.                                 if (desiredType == cChar)
  6020.                                     *result = (**theHTE).teLength;
  6021.                                     
  6022.                                 if (desiredType == cLine)
  6023.                                     *result = CountLines(theHTE);
  6024.                                     
  6025.                             }
  6026.                     }
  6027.                     
  6028.                 myErr = AECoerceDesc(container, typeMyText, &newDesc);
  6029.                 if (newDesc.descriptorType!=typeNull)
  6030.                     {
  6031.                         GetRawDataFromDescriptor(    &newDesc,
  6032.                                                                             (Ptr)&theTextToken,
  6033.                                                                             sizeof(theTextToken),
  6034.                                                                             &tokenSize);
  6035.                                                                          
  6036.                         ignoreErr = AEDisposeDesc(&newDesc);
  6037.                                                                          
  6038.                         theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  6039.                         theHTE      = theDocument->theText;
  6040.                         
  6041.                         if (desiredType == cWord)
  6042.                             {
  6043.                                 wordStart   = theTextToken.tokenOffset-1;
  6044.                                 wordLength  = theTextToken.tokenLength;
  6045.                                 *result     = CountWords(theHTE, wordStart, wordLength);
  6046.                             }
  6047.                         
  6048.                         if (desiredType == cChar)
  6049.                             *result = theTextToken.tokenLength;
  6050.                             
  6051.                         if (desiredType == cLine)
  6052.                             *result= LineOfOffset(theHTE,theTextToken.tokenOffset-1) - 
  6053.                                              LineOfOffset(theHTE,theTextToken.tokenOffset+theTextToken.tokenLength-1)
  6054.                                              +1;                        
  6055.                     }
  6056.                     
  6057.             }
  6058.             
  6059.         return(myErr);
  6060.     }    /* MyCountProc */
  6061.  
  6062. /*******************************************************************************/
  6063. /*
  6064.     Coercion Handlers - Allow AEResolve to do the hard work
  6065. */
  6066. pascal OSErr CoerceObjToAnything(const AEDesc *theAEDesc,
  6067.                                                              DescType     toType,
  6068.                                                          long         handlerRefCon,
  6069.                                                              AEDesc       *result)
  6070. /*
  6071.     CoerceObjToAnything functions by using AEResolve to do the hard
  6072.     work.
  6073. */
  6074.     {
  6075. #pragma unused (handlerRefCon)
  6076.     
  6077.         OSErr  myErr;
  6078.         OSErr  ignoreErr;
  6079.         
  6080.         AEDesc objDesc;
  6081.             
  6082.         myErr = errAECoercionFail;
  6083.         
  6084.         result->dataHandle = nil;
  6085.         objDesc.dataHandle = nil;
  6086.         
  6087.         
  6088.         if (theAEDesc->descriptorType != typeObjectSpecifier)
  6089.             {
  6090.                 return(errAEWrongDataType);
  6091.             }
  6092.         
  6093.         /* resolve the object specifier */
  6094.         myErr = AEResolve(theAEDesc, kAEIDoMinimum, &objDesc);
  6095.             
  6096.         /* hopefully it's the right type by now, but we'll give it a nudge */
  6097.         if (myErr==noErr)
  6098.             {
  6099.                 myErr = AECoerceDesc(&objDesc, toType, result);
  6100.                 ignoreErr = AEDisposeDesc(&objDesc);
  6101.             }
  6102.             
  6103.         return(myErr);
  6104.     }    /* CoerceObjToAnything */
  6105.  
  6106.  
  6107. /* -----------------------------------------------------------------------
  6108.         Name:             InitAppleEvents
  6109.         Purpose:        Initialise the AppleEvent despatch table
  6110.      -----------------------------------------------------------------------**/
  6111.  
  6112. #pragma segment Main
  6113.  
  6114. #define noRefCon -1
  6115.  
  6116.  
  6117. pascal void InitAppleEvents(void)
  6118.     {
  6119.          OSErr aevtErr;
  6120.         
  6121.         gBigBrother    = 0;
  6122.         gCharsInBuffer = 0;
  6123.         gTypingBuffer  = (char *)NewPtr(32000);
  6124.         gTypingTargetObject.dataHandle = 0;
  6125.         
  6126.         /*set up the despatch table for the four standard apple events*/
  6127.         
  6128.         aevtErr = AEInstallEventHandler( kCoreEventClass, kAEOpenApplication, NewAEEventHandlerProc(DoOpenApp), noRefCon, false) ;
  6129.         aevtErr = AEInstallEventHandler( kCoreEventClass, kAEOpenDocuments,   NewAEEventHandlerProc(DoOpenDocument), noRefCon, false) ;
  6130.         aevtErr = AEInstallEventHandler( kCoreEventClass, kAEPrintDocuments,  NewAEEventHandlerProc(DoPrintDocuments), noRefCon, false) ;
  6131.         aevtErr = AEInstallEventHandler( kCoreEventClass, kAEQuitApplication, NewAEEventHandlerProc(MyQuit), noRefCon, false) ;
  6132.         
  6133.         /* set up the despatch table for the core AppleEvents for text */
  6134.         
  6135.         aevtErr = AEInstallEventHandler( kAECoreSuite,     kAEDelete, NewAEEventHandlerProc(DoDeleteEdit),noRefCon, false);
  6136.  
  6137.         aevtErr = AEInstallEventHandler( kAEMiscStandards, kAECut,    NewAEEventHandlerProc(DoCutEdit),   noRefCon, false);
  6138.         aevtErr = AEInstallEventHandler( kAEMiscStandards, kAECopy,   NewAEEventHandlerProc(DoCopyEdit),  noRefCon, false);
  6139.         aevtErr = AEInstallEventHandler( kAEMiscStandards, kAEPaste,  NewAEEventHandlerProc(DoPasteEdit), noRefCon, false);
  6140.         aevtErr = AEInstallEventHandler( kAECoreSuite,     kAESetData,NewAEEventHandlerProc(DoSetData),   noRefCon, false);
  6141.         aevtErr = AEInstallEventHandler( kAECoreSuite,     kAEGetData,NewAEEventHandlerProc(DoGetData),   noRefCon, false);
  6142.         aevtErr = AEInstallEventHandler( kAECoreSuite,     kAEGetDataSize,NewAEEventHandlerProc(DoGetDataSize),   noRefCon, false);
  6143.         
  6144.         aevtErr = AEInstallEventHandler( kAECoreSuite, kAECountElements,   NewAEEventHandlerProc(HandleNumberOfElements),   noRefCon, false);
  6145.         aevtErr = AEInstallEventHandler( kAECoreSuite, kAECreateElement,   NewAEEventHandlerProc(DoNewElement),   noRefCon, false);
  6146.         aevtErr = AEInstallEventHandler( kAECoreSuite, kAEDoObjectsExist,  NewAEEventHandlerProc(DoIsThereA),   noRefCon, false);
  6147.     
  6148.         aevtErr = AEInstallEventHandler( kAECoreSuite,     kAEMove,   NewAEEventHandlerProc(DoMoveWindow),noRefCon, false);
  6149.         aevtErr = AEInstallEventHandler( kAECoreSuite,     kAEClose,  NewAEEventHandlerProc(DoCloseWindow),noRefCon, false);
  6150.         aevtErr = AEInstallEventHandler( kAECoreSuite,     kAESave,   NewAEEventHandlerProc(DoSaveWindow),noRefCon, false);
  6151.         aevtErr = AEInstallEventHandler( kAEMiscStandards, kAERevert, NewAEEventHandlerProc(DoRevertWindow),noRefCon, false);
  6152.         
  6153.         aevtErr = AEInstallEventHandler( kAEMiscStandards, kAEMakeObjectsVisible, NewAEEventHandlerProc(HandleShowSelection),   noRefCon, false);
  6154.  
  6155.         /* Now look for recording notifications */
  6156.         
  6157.         aevtErr = AEInstallEventHandler( kCoreEventClass, kAEStartedRecording, NewAEEventHandlerProc(HandleStartRecording), noRefCon, false);
  6158.         aevtErr = AEInstallEventHandler( kCoreEventClass, kAEStoppedRecording, NewAEEventHandlerProc(HandleStopRecording), noRefCon, false);
  6159.         
  6160.         /* Now Put in the required object accessors */
  6161.         
  6162.         aevtErr = AESetObjectCallbacks(nil,NewOSLCountProc(MyCountProc),nil,nil,nil,nil,nil);
  6163.         
  6164.         aevtErr = AEInstallObjectAccessor(cWindow,      typeNull,   NewOSLAccessorProc(WindowFromNullAccessor),  0,false);
  6165.         aevtErr = AEInstallObjectAccessor(cWindow,      typeMyAppl, NewOSLAccessorProc(WindowFromNullAccessor),  0,false);
  6166.                 
  6167.         aevtErr = AEInstallObjectAccessor(cApplication, typeNull,   NewOSLAccessorProc(ApplicationFromNullAccessor),  0,false);
  6168.         aevtErr = AEInstallObjectAccessor(cProperty,    typeMyAppl, NewOSLAccessorProc(PropertyFromApplAccessor),0,false);
  6169.         
  6170.         aevtErr = AEInstallObjectAccessor(cChar,             typeMyWndw,NewOSLAccessorProc(TextElemFromWndwAccessor),0,false);
  6171.         aevtErr = AEInstallObjectAccessor(cSpot,             typeMyWndw,NewOSLAccessorProc(TextElemFromWndwAccessor),0,false);
  6172.         aevtErr = AEInstallObjectAccessor(cWord,             typeMyWndw,NewOSLAccessorProc(TextElemFromWndwAccessor),0,false);
  6173.         aevtErr = AEInstallObjectAccessor(cLine,             typeMyWndw,NewOSLAccessorProc(TextElemFromWndwAccessor),0,false);
  6174.         aevtErr = AEInstallObjectAccessor(cProperty,   typeMyWndw,NewOSLAccessorProc(PropertyFromWndwAccessor),0,false);
  6175.  
  6176.    aevtErr = AEInstallObjectAccessor(cProperty,    typeMyWindowProp, NewOSLAccessorProc(PropertyFromWinPropertyAccessor),0,false);    
  6177.  
  6178.         aevtErr = AEInstallObjectAccessor(cProperty,     typeMyText,NewOSLAccessorProc(PropertyFromTextAccessor),0,false);
  6179.         aevtErr = AEInstallObjectAccessor(cChar,           typeMyText,NewOSLAccessorProc(TextElemFromTextAccessor),0,false);
  6180.         aevtErr = AEInstallObjectAccessor(cWord,           typeMyText,NewOSLAccessorProc(TextElemFromTextAccessor),0,false);
  6181.         aevtErr = AEInstallObjectAccessor(cSpot,           typeMyText,NewOSLAccessorProc(TextElemFromTextAccessor),0,false);
  6182.         aevtErr = AEInstallObjectAccessor(cLine,           typeMyText,NewOSLAccessorProc(TextElemFromTextAccessor),0,false);
  6183.         
  6184.         aevtErr = AEInstallObjectAccessor(cMenu,           typeNull,       NewOSLAccessorProc(MenuFromNullAccessor),    0,false);
  6185.         aevtErr = AEInstallObjectAccessor(cProperty,   typeMyMenu,     NewOSLAccessorProc(PropertyFromMenuAccessor),0,false);
  6186.         aevtErr = AEInstallObjectAccessor(cProperty,   typeMyMenuItem, NewOSLAccessorProc(PropertyFromMenuItemAccessor),0,false);
  6187.         aevtErr = AEInstallObjectAccessor(cMenuItem,   typeMyMenu,     NewOSLAccessorProc(MenuItemFromMenuAccessor),0,false);
  6188.         /* Now the coercion handlers */
  6189.  
  6190.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyAppl,      (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything), 0, true, false);
  6191.         aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyWndw,      (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything), 0, true, false);
  6192.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyText,      (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything), 0, true, false);
  6193.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyTextProp,  (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything), 0, true, false);
  6194.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyWindowProp,(AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything), 0, true, false);
  6195.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyApplProp,  (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything), 0, true, false);
  6196.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyMenu,      (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything), 0, true, false);
  6197.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyMenuProp,  (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything), 0, true, false);
  6198.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyMenuItem,  (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything), 0, true, false);
  6199.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyItemProp,  (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything), 0, true, false);
  6200.  
  6201.  } /* InitAppleEvents */
  6202.